{"id":4499,"date":"2022-06-20T16:55:49","date_gmt":"2022-06-20T14:55:49","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=4499"},"modified":"2022-06-20T16:55:52","modified_gmt":"2022-06-20T14:55:52","slug":"requires-expressions-and-requires-clauses-in-cpp20","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/","title":{"rendered":"requires expressions and requires clauses in C++20"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">The C++20 standard added constraints and concepts to the language. This addition introduced two new keywords into the language, <code>concept<\/code> and <code>requires<\/code>. The former is used to declare a concept, while the latter is used to introduce a <strong>requires expression<\/strong> or a <strong>requires clause<\/strong>. These two could be confusion at first, so let&#8217;s take a look at which is which and what is their purpose.<\/p>\n\n\n\n<!--more-->\n\n\n\n<p class=\"wp-block-paragraph\">Let&#8217;s start with the following example:<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><a href=\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires.png\"><img loading=\"lazy\" decoding=\"async\" width=\"700\" height=\"495\" src=\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires-700x495.png\" alt=\"\" class=\"wp-image-4500\" srcset=\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires-700x495.png 700w, https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires-300x212.png 300w, https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires-768x543.png 768w, https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires.png 1033w\" sizes=\"auto, (max-width: 700px) 100vw, 700px\" \/><\/a><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">In this snippet, we have the following:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>A concept, called <code>Composable<\/code>, whose body consists of a requires expression (containing a single constraint). The requires expression is <code>requires(T a, T b) { a + b; }<\/code>.<\/li><li>A function template called <code>add<\/code>, that constrains its template argument <code>T<\/code> using the <code>Composable<\/code> concept within a requires clause, which is <code>requires Composable&lt;T&gt;<\/code>.<\/li><li>A function template also called <code>add<\/code>, that constrains its template argument <code>T<\/code> using the requires expression <code>requires(T a, T b) { a + b; }<\/code> directly in a requires clause (<code>requires requires(T a, T b) { a + b; }<\/code>).<\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Let&#8217;s discuss them one by one.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">requires expressions<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">A requires expression is a compile-time expression of type <code>bool<\/code> that describes the constraints on one or more template arguments. There are several categories of requires expressions:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li><strong>simple requirements<\/strong>, such as the one we just saw earlier.<\/li><li><strong>type requirements<\/strong>, requires that a named type is valid; such a requirement starts with the typename keyword<\/li><li><strong>compound requirements<\/strong>, assert properties of an expression<\/li><li><strong>nested requirements<\/strong>, introduced with the <code>requires<\/code> keyword, can be used to specify additional constraints in terms of local parameters.<\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Let&#8217;s see an example that includes all of these:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nconcept Fooable = requires(T a)\n{\n   \/\/ simple requirements\n   a++;                                      \/\/ can be post-incremented\n   ++a;                                      \/\/ can be pre-incremented\n\n   \/\/ type requirements\n   typename T::value_type;                   \/\/ has inner type member value_type\n\n   \/\/ compound requirements\n   { a + 1 } -> std::convertible_to&lt;T>;      \/\/ a + 1 is a valid expression AND\n                                             \/\/ its result must be convertible to T\n\n   \/\/ nested requirements\n   requires std::same_as&lt;T*, decltype(&amp;a)>;  \/\/ operator&amp; returns the same type as T*\n};<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">There are some important things to keep in mind here:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>A requires expression is a compile-time expression of the type <code>bool<\/code> and can appear anywhere a compile-time Boolean can appear (such as <code>if constexpr<\/code> or <code>static_assert<\/code> statements). Requires expressions are not limited to the body of concepts or in requires clauses.<\/li><li>The expressions inside a requires expression are never evaluated. The <code>T a<\/code> object in the example above does not have a lifetime. It&#8217;s never instantiated. The only thing the compiler does is ensuring that the expressions where it is present (such as <code>a++<\/code> or <code>a + 1<\/code> or <code>decltype(&amp;a)<\/code>) are valid, i.e. well-formed.<\/li><li>Requires expressions in a template are evaluated when the template is instantiated. They can evaluate to either <code>true<\/code> or <code>false<\/code>. If the body of a requires expression is empty the expression evaluates to <code>true<\/code>.<\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Here is an example of requires expressions used within the body of a function template:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">struct point\n{\n   int x;\n   int y;\n};\n\nstd::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, point const&amp; p)\n{\n   os &lt;&lt; '(' &lt;&lt; p.x &lt;&lt; ',' &lt;&lt; p.y &lt;&lt; ')';\n   return os;\n}\n\ntemplate &lt;typename T>\nconstexpr bool always_false = std::false_type::value;\n\ntemplate &lt;typename T>\nstd::string as_string(T a)\n{\n   constexpr bool has_to_string = requires(T x)\n   {\n      { std::to_string(x) } -> std::convertible_to&lt;std::string>;\n   };\n\n   constexpr bool has_stream = requires(T x, std::ostream&amp; os)\n   {\n      {os &lt;&lt; x} -> std::same_as&lt;std::ostream&amp;>;\n   };\n\n   if constexpr (has_to_string)\n   {\n      return std::to_string(a);\n   }\n   else if constexpr (has_stream)\n   {\n      std::stringstream s;\n      s &lt;&lt; a;\n      return s.str();\n   }\n   else\n      static_assert(always_false&lt;T>, \"The type cannot be serialized\");\n}\n\nint main()\n{\n   std::cout &lt;&lt; as_string(42) &lt;&lt; '\\n';\n   std::cout &lt;&lt; as_string(point{1, 2}) &lt;&lt; '\\n';\n   std::cout &lt;&lt; as_string(std::pair&lt;int, int>{1, 2}) &lt;&lt; '\\n'; \/\/ error: The type cannot be serialized\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">In this example, the <code>as_string<\/code> function is an uniform interface to serialize objects to string. For this purpose, it uses either the <code>std::to_string<\/code> function or the overloaded output stream operator <code>&lt;&lt;<\/code>. To select between these, two requires expressions are used; their purpose is to identify whether the expressions <code>std::to_string(x)<\/code> or <code>os &lt;&lt; x<\/code> are valid (where <code>x<\/code> is a <code>T<\/code>) and what  is their return type. As a result, calling <code>as_string(42)<\/code> and <code>as_string(point{1, 2})<\/code> are both successful, but <code>as_string(std::pair&lt;int, int>{1, 2})<\/code> triggers a compiling error because neither of the two requires expressions is evaluated to <code>true<\/code>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">requires clauses<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">A requires clause is a way to specify a constraint on a template argument or function declaration. The <code>requires<\/code> keyword must be followed by a constant expression. The idea is though, that this constant expression should be a concept or a conjunction\/disjunction of concepts. Alternatively it could also be a requires expression, in which case we have the curious syntax <code>requires requires expr<\/code> (that we&#8217;ve seen in the image above).<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Here is an example of a requires clause:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nT increment(T a) requires std::integral&lt;T>\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The same requirement can be expressed as follows, with the requires clause following the template parameter list:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T> requires std::integral&lt;T>\nT increment(T a)\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">This example used a single concept in the require clause. It constraints the template argument <code>T<\/code> to be of an integral type. The next snippet shows a disjunction of two concepts, that extends the constraint to include floating-point types too:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nT increment(T a)\n   requires std::integral&lt;T> || std::floating_point&lt;T>\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">If we want to allow any type T for which the operation a + 1 is supported, we can use a requires clause with a requires expression, as follows:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nT increment(T a)\n   requires requires (T x) { x + 1; }\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">This example is perhaps a little bit silly, since we just replicate the expression in the return statement, but its purpose is to demonstrate the syntax for requires clauses.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">However, not every expression of the type <code>bool<\/code> is allowed in a requires clause. Here is an example that does not work:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nT increment(T a) requires !std::floating_point&lt;T>\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">Here is what you get with Clang\/gcc (the VC++ compiler doesn&#8217;t seem to have a problem with this):<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"raw\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">prog.cc:5:27: error: parentheses are required around this expression in a requires clause\nT increment(T a) requires !std::floating_point&lt;T>\n                          ^~~~~~~~~~~~~~~~~~~~~~~\n                          (                      )<\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The expression in a requires clause may contain the following:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>the <code>bool<\/code> literals <code>true<\/code> and <code>false<\/code><\/li><li>names of variables of the <code>bool<\/code> type (such as <code>value<\/code>, <code>value&lt;T><\/code>, <code>T::value<\/code>)<\/li><li>concepts (such as <code>std::integral&lt;T><\/code>)<\/li><li>requires expressions<\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">For anything else, wrapping parenthesis must be used as follows:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"cpp\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">template &lt;typename T>\nT increment(T a) requires (!std::floating_point&lt;T>)\n{\n   return a + 1;\n}<\/pre>\n\n\n\n<h2 class=\"wp-block-heading\">Wrapping up<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">So what is the purpose of requires expressions and requires clauses?<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>A <strong>requires expression<\/strong> is Boolean expression that can be used with a requires clause or to define the body of a named concept (which in turn is used with a requires clause). Its purpose is to determine if one or more expressions are well-formed. It has no side effects and does not affect the behavior of the program.<\/li><li>A <strong>requires clause<\/strong> uses a compile-time Boolean expression to define requirements on template arguments or function declarations. It affects the behavior of a program, determining whether a function participates in overload resolution or not or whether a template instantiation is valid.<\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">There is more to these topics than what I have presented here. To learn more about these, see the following articles:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li><a href=\"https:\/\/en.cppreference.com\/w\/cpp\/language\/constraints\" target=\"_blank\" rel=\"noreferrer noopener\">Constraints and concepts<\/a><\/li><li><a href=\"https:\/\/akrzemi1.wordpress.com\/2020\/01\/29\/requires-expression\/\" target=\"_blank\" rel=\"noreferrer noopener\">Requires-expression<\/a><\/li><li><a href=\"https:\/\/akrzemi1.wordpress.com\/2020\/03\/26\/requires-clause\/\" target=\"_blank\" rel=\"noreferrer noopener\">Requires-clause<\/a><\/li><li><a href=\"https:\/\/www.sandordargo.com\/blog\/2021\/03\/10\/write-your-own-cpp-concepts-part-i\" target=\"_blank\" rel=\"noreferrer noopener\">How to write your own C++ concepts? Part I<\/a><\/li><li><a href=\"https:\/\/www.sandordargo.com\/blog\/2021\/03\/17\/write-your-own-cpp-concepts-part-ii\" target=\"_blank\" rel=\"noreferrer noopener\">How to write your own C++ concepts? Part II<\/a><\/li><\/ul>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n","protected":false},"excerpt":{"rendered":"<p>The C++20 standard added constraints and concepts to the language. This addition introduced two new keywords into the language, concept and requires. The former is used to declare a concept, while the latter is used to introduce a requires expression or a requires clause. These two could be confusion at first, so let&#8217;s take a &#8230; <a title=\"requires expressions and requires clauses in C++20\" class=\"read-more\" href=\"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/\" aria-label=\"Read more about requires expressions and requires clauses in C++20\">Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,543,153],"class_list":["post-4499","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-c20","tag-concepts"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 5.0.1.1 - aioseo.com -->\n\t<meta name=\"description\" content=\"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Marius Bancila\"\/>\n\t<meta name=\"keywords\" content=\"c++,c++20,concepts\" \/>\n\t<link rel=\"canonical\" href=\"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 5.0.1.1\" \/>\n\t\t<meta property=\"og:locale\" content=\"en_US\" \/>\n\t\t<meta property=\"og:site_name\" content=\"Marius Bancila&#039;s Blog | About code. Mostly on C++\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"requires expressions and requires clauses in C++20\" \/>\n\t\t<meta property=\"og:description\" content=\"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2022-06-20T14:55:49+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"2022-06-20T14:55:52+00:00\" \/>\n\t\t<meta name=\"twitter:card\" content=\"summary\" \/>\n\t\t<meta name=\"twitter:title\" content=\"requires expressions and requires clauses in C++20\" \/>\n\t\t<meta name=\"twitter:description\" content=\"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.\" \/>\n\t\t<script type=\"application\/ld+json\" class=\"aioseo-schema\">\n\t\t\t{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#article\",\"name\":\"requires expressions and requires clauses in C++20\",\"headline\":\"requires expressions and requires clauses in C++20\",\"author\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/author\\\/admin\\\/#author\"},\"publisher\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/#organization\"},\"image\":{\"@type\":\"ImageObject\",\"url\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/requires.png\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#articleImage\",\"width\":1033,\"height\":731},\"datePublished\":\"2022-06-20T16:55:49+02:00\",\"dateModified\":\"2022-06-20T16:55:52+02:00\",\"inLanguage\":\"en-US\",\"commentCount\":2,\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#webpage\"},\"isPartOf\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#webpage\"},\"articleSection\":\"C++, C++, c++20, concepts\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#breadcrumblist\",\"itemListElement\":[{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog#listItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/#listItem\",\"name\":\"IT\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/#listItem\",\"position\":2,\"name\":\"IT\",\"item\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/#listItem\",\"name\":\"Software\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog#listItem\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/#listItem\",\"position\":3,\"name\":\"Software\",\"item\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/c\\\/#listItem\",\"name\":\"C++\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/#listItem\",\"name\":\"IT\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/c\\\/#listItem\",\"position\":4,\"name\":\"C++\",\"item\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/c\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#listItem\",\"name\":\"requires expressions and requires clauses in C++20\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/#listItem\",\"name\":\"Software\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#listItem\",\"position\":5,\"name\":\"requires expressions and requires clauses in C++20\",\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/category\\\/it\\\/software\\\/c\\\/#listItem\",\"name\":\"C++\"}}]},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/#organization\",\"name\":\"Marius Bancila's Blog\",\"description\":\"About code. Mostly on C++\",\"url\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/author\\\/admin\\\/#author\",\"url\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/author\\\/admin\\\/\",\"name\":\"Marius Bancila\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#authorImage\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/a84dd2831d955c38355ddea55df4df260809b88f36408bc14fd4eab8f7f131c9?s=96&d=mm&r=g\",\"width\":96,\"height\":96,\"caption\":\"Marius Bancila\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#webpage\",\"url\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/\",\"name\":\"requires expressions and requires clauses in C++20\",\"description\":\"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.\",\"inLanguage\":\"en-US\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/#website\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/2022\\\/06\\\/20\\\/requires-expressions-and-requires-clauses-in-cpp20\\\/#breadcrumblist\"},\"author\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/author\\\/admin\\\/#author\"},\"creator\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/author\\\/admin\\\/#author\"},\"datePublished\":\"2022-06-20T16:55:49+02:00\",\"dateModified\":\"2022-06-20T16:55:52+02:00\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/\",\"name\":\"Marius Bancila's Blog\",\"description\":\"About code. Mostly on C++\",\"inLanguage\":\"en-US\",\"publisher\":{\"@id\":\"https:\\\/\\\/mariusbancila.ro\\\/blog\\\/#organization\"}}]}\n\t\t<\/script>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"requires expressions and requires clauses in C++20","description":"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.","canonical_url":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/","robots":"max-image-preview:large","keywords":"c++,c++20,concepts","webmasterTools":{"miscellaneous":""},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#article","name":"requires expressions and requires clauses in C++20","headline":"requires expressions and requires clauses in C++20","author":{"@id":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/#author"},"publisher":{"@id":"https:\/\/mariusbancila.ro\/blog\/#organization"},"image":{"@type":"ImageObject","url":"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2022\/06\/requires.png","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#articleImage","width":1033,"height":731},"datePublished":"2022-06-20T16:55:49+02:00","dateModified":"2022-06-20T16:55:52+02:00","inLanguage":"en-US","commentCount":2,"mainEntityOfPage":{"@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#webpage"},"isPartOf":{"@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#webpage"},"articleSection":"C++, C++, c++20, concepts"},{"@type":"BreadcrumbList","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog#listItem","position":1,"name":"Home","item":"https:\/\/mariusbancila.ro\/blog","nextItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/#listItem","name":"IT"}},{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/#listItem","position":2,"name":"IT","item":"https:\/\/mariusbancila.ro\/blog\/category\/it\/","nextItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/#listItem","name":"Software"},"previousItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog#listItem","name":"Home"}},{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/#listItem","position":3,"name":"Software","item":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/","nextItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/#listItem","name":"C++"},"previousItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/#listItem","name":"IT"}},{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/#listItem","position":4,"name":"C++","item":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/","nextItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#listItem","name":"requires expressions and requires clauses in C++20"},"previousItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/#listItem","name":"Software"}},{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#listItem","position":5,"name":"requires expressions and requires clauses in C++20","previousItem":{"@type":"ListItem","@id":"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/#listItem","name":"C++"}}]},{"@type":"Organization","@id":"https:\/\/mariusbancila.ro\/blog\/#organization","name":"Marius Bancila's Blog","description":"About code. Mostly on C++","url":"https:\/\/mariusbancila.ro\/blog\/"},{"@type":"Person","@id":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/#author","url":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/","name":"Marius Bancila","image":{"@type":"ImageObject","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#authorImage","url":"https:\/\/secure.gravatar.com\/avatar\/a84dd2831d955c38355ddea55df4df260809b88f36408bc14fd4eab8f7f131c9?s=96&d=mm&r=g","width":96,"height":96,"caption":"Marius Bancila"}},{"@type":"WebPage","@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#webpage","url":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/","name":"requires expressions and requires clauses in C++20","description":"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.","inLanguage":"en-US","isPartOf":{"@id":"https:\/\/mariusbancila.ro\/blog\/#website"},"breadcrumb":{"@id":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/#breadcrumblist"},"author":{"@id":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/#author"},"creator":{"@id":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/#author"},"datePublished":"2022-06-20T16:55:49+02:00","dateModified":"2022-06-20T16:55:52+02:00"},{"@type":"WebSite","@id":"https:\/\/mariusbancila.ro\/blog\/#website","url":"https:\/\/mariusbancila.ro\/blog\/","name":"Marius Bancila's Blog","description":"About code. Mostly on C++","inLanguage":"en-US","publisher":{"@id":"https:\/\/mariusbancila.ro\/blog\/#organization"}}]},"og:locale":"en_US","og:site_name":"Marius Bancila's Blog | About code. Mostly on C++","og:type":"article","og:title":"requires expressions and requires clauses in C++20","og:description":"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.","og:url":"https:\/\/mariusbancila.ro\/blog\/2022\/06\/20\/requires-expressions-and-requires-clauses-in-cpp20\/","article:published_time":"2022-06-20T14:55:49+00:00","article:modified_time":"2022-06-20T14:55:52+00:00","twitter:card":"summary","twitter:title":"requires expressions and requires clauses in C++20","twitter:description":"A overview of the requires expressions and requires clauses introduced in C++20 for concepts."},"aioseo_meta_data":{"post_id":"4499","title":null,"description":"A overview of the requires expressions and requires clauses introduced in C++20 for concepts.","keywords":[],"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":[],"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":{"id":"aioseo-article-6369651300dad","slug":"article","graphName":"Article","label":"Article","properties":{"type":"BlogPosting","name":"#post_title","headline":"#post_title","description":"#post_excerpt","image":"","keywords":"","author":{"name":"#author_name","url":"#author_url"},"dates":{"include":true,"datePublished":"","dateModified":""}}},"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":"{\"article\":{\"articleType\":\"BlogPosting\"},\"course\":{\"name\":\"\",\"description\":\"\",\"provider\":\"\"},\"faq\":{\"pages\":[]},\"product\":{\"reviews\":[]},\"recipe\":{\"ingredients\":[],\"instructions\":[],\"keywords\":[]},\"software\":{\"reviews\":[],\"operatingSystems\":[]},\"webPage\":{\"webPageType\":\"WebPage\"}}","pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"ai":null,"created":"2022-06-06 13:38:15","updated":"2025-12-12 07:57:11","seo_analyzer_scan_date":null,"focus_keyword":null,"additional_keywords":null,"truseo_locale":null},"author_meta":{"display_name":"Marius Bancila","author_link":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/"},"featured_img":null,"jetpack_publicize_connections":[],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Marius Bancila","author_link":"https:\/\/mariusbancila.ro\/blog\/author\/admin\/"},"uagb_comment_info":2,"uagb_excerpt":"The C++20 standard added constraints and concepts to the language. This addition introduced two new keywords into the language, concept and requires. The former is used to declare a concept, while the latter is used to introduce a requires expression or a requires clause. These two could be confusion at first, so let&#8217;s take a&hellip;","coauthors":[],"tax_additional":{"categories":{"linked":["<a href=\"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/\" class=\"advgb-post-tax-term\">C++<\/a>"],"unlinked":["<span class=\"advgb-post-tax-term\">C++<\/span>"]},"tags":{"linked":["<a href=\"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/\" class=\"advgb-post-tax-term\">C++<\/a>","<a href=\"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/\" class=\"advgb-post-tax-term\">c++20<\/a>","<a href=\"https:\/\/mariusbancila.ro\/blog\/category\/it\/software\/c\/\" class=\"advgb-post-tax-term\">concepts<\/a>"],"unlinked":["<span class=\"advgb-post-tax-term\">C++<\/span>","<span class=\"advgb-post-tax-term\">c++20<\/span>","<span class=\"advgb-post-tax-term\">concepts<\/span>"]}},"comment_count":"2","relative_dates":{"created":"Posted 4 years ago","modified":"Updated 4 years ago"},"absolute_dates":{"created":"Posted on June 20, 2022","modified":"Updated on June 20, 2022"},"absolute_dates_time":{"created":"Posted on June 20, 2022 4:55 pm","modified":"Updated on June 20, 2022 4:55 pm"},"featured_img_caption":"","series_order":"","jetpack_shortlink":"https:\/\/wp.me\/pYNdv-1az","jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/posts\/4499","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/comments?post=4499"}],"version-history":[{"count":15,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/posts\/4499\/revisions"}],"predecessor-version":[{"id":4516,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/posts\/4499\/revisions\/4516"}],"wp:attachment":[{"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/media?parent=4499"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/categories?post=4499"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mariusbancila.ro\/blog\/wp-json\/wp\/v2\/tags?post=4499"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}