[expr.prim] - C++20 → C++23

Files changed (1) hide show

tmp/tmpu8wqb_qu/{from.md → to.md} +385 -240

tmp/tmpu8wqb_qu/{from.md → to.md} RENAMED Viewed

@@ -11,35 +11,43 @@ primary-expression:
     requires-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
-A *literal* is a primary expression. The type of a *literal* is
-determined based on its form as specified in [[lex.literal]]. A
-*string-literal* is an lvalue, a *user-defined-literal* has the same
-value category as the corresponding operator call expression described
-in [[lex.ext]], and any other *literal* is a prvalue.
 ### This <a id="expr.prim.this">[[expr.prim.this]]</a>
-The keyword `this` names a pointer to the object for which a non-static
-member function [[class.this]] is invoked or a non-static data member’s
-initializer [[class.mem]] is evaluated.
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
-*cv-qualifier-seq* `X`” between the optional *cv-qualifier-seq* and the
-end of the *function-definition*, *member-declarator*, or *declarator*.
-It shall not appear before the optional *cv-qualifier-seq* and it shall
-not appear within the declaration of a static member function (although
-its type and value category are defined within a static member function
-as they are within a non-static member function).
-[*Note 1*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
-[*Note 2*:
 In a *trailing-return-type*, the class being defined is not required to
 be complete for purposes of class member access [[expr.ref]]. Class
 members declared later are not visible.
@@ -58,21 +66,21 @@ template auto A::f(int t) -> decltype(t + g());
 — *end note*]
 Otherwise, if a *member-declarator* declares a non-static data member
 [[class.mem]] of a class `X`, the expression `this` is a prvalue of type
-“pointer to `X`” within the optional default member initializer
-[[class.mem]]. It shall not appear elsewhere in the *member-declarator*.
 The expression `this` shall not appear in any other context.
 [*Example 2*:
 ``` cpp
 class Outer {
   int a[sizeof(*this)];                 // error: not inside a member function
-  unsigned int sz = sizeof(*this);      // OK: in default member initializer
   void f() {
     int b[sizeof(*this)];               // OK
     struct Inner {
@@ -85,16 +93,19 @@ class Outer {
 — *end example*]
 ### Parentheses <a id="expr.prim.paren">[[expr.prim.paren]]</a>
 A parenthesized expression `(E)` is a primary expression whose type,
-value, and value category are identical to those of E. The parenthesized
-expression can be used in exactly the same contexts as those where E can
-be used, and with the same meaning, except as otherwise indicated.
 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
@@ -102,63 +113,71 @@ id-expression:
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
-An *id-expression* that denotes a non-static data member or non-static
-member function of a class can only be used:
 - as part of a class member access [[expr.ref]] in which the object
   expression refers to the member’s class[^10] or a class derived from
   that class, or
 - to form a pointer to member [[expr.unary.op]], or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
-  \[*Example 1*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
-A potentially-evaluated *id-expression* that denotes an immediate
-function [[dcl.constexpr]] shall appear only
-- as a subexpression of an immediate invocation, or
-- in an immediate function context [[expr.const]].
 For an *id-expression* that denotes an overload set, overload resolution
-is performed to select a unique function ([[over.match]],
-[[over.over]]).
-[*Note 2*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
-[*Example 2*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
-}
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
 declaration of `p2`, those constraints are required to be satisfied even
-though `f` is an unevaluated operand [[expr.prop]].
 — *end example*]
 — *end note*]
@@ -185,56 +204,109 @@ the copy of the parameter [[dcl.fct.def.coroutine]].
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
 [[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
 denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
 Within the definition of a non-static member function, an *identifier*
 that names a non-static member is transformed to a class member access
-expression ([[class.mfct.non-static]]). — *end note*]
-The result is the entity denoted by the identifier. If the entity is a
-local entity and naming it from outside of an unevaluated operand within
-the declarative region where the *unqualified-id* appears would result
-in some intervening *lambda-expression* capturing it by copy
-[[expr.prim.lambda.capture]], the type of the expression is the type of
-a class member access expression [[expr.ref]] naming the non-static data
-member that would be declared for such a capture in the closure object
-of the innermost such intervening *lambda-expression*.
-[*Note 2*: If that *lambda-expression* is not declared `mutable`, the
   type of such an identifier will typically be `const`
   qualified. — *end note*]
-The type of the expression is the type of the result.
-[*Note 3*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
 `const T`. — *end note*]
-[*Note 4*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
-The expression is an lvalue if the entity is a function, variable,
-structured binding [[dcl.struct.bind]], data member, or template
-parameter object and a prvalue otherwise [[basic.lval]]; it is a
-bit-field if the identifier designates a bit-field.
 [*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
-  [=] {
     decltype(x) y1;             // y1 has type float
-    decltype((x)) y2 = y1;      // y2 has type float const& because this lambda
-                                // is not mutable and x is an lvalue
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
   };
 }
 ```
 — *end example*]
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier templateₒₚₜ unqualified-id
@@ -248,56 +320,66 @@ nested-name-specifier:
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
-The type denoted by a *decltype-specifier* in a *nested-name-specifier*
-shall be a class or enumeration type.
-A *nested-name-specifier* that denotes a class, optionally followed by
-the keyword `template` [[temp.names]], and then followed by the name of
-a member of either that class [[class.mem]] or one of its base classes
-[[class.derived]], is a *qualified-id*;  [[class.qual]] describes name
-lookup for class members that appear in *qualified-id*s. The result is
-the member. The type of the result is the type of the member. The result
-is an lvalue if the member is a static member function or a data member
 and a prvalue otherwise.
-[*Note 1*: A class member can be referred to using a *qualified-id* at
-any point in its potential scope [[basic.scope.class]]. — *end note*]
-Where *type-name* `::~` *type-name* is used, the two *type-name*s shall
-refer to the same type (ignoring cv-qualifications); this notation
-denotes the destructor of the type so named [[expr.prim.id.dtor]]. The
-*unqualified-id* in a *qualified-id* shall not be of the form
-`~`*decltype-specifier*.
-The *nested-name-specifier* `::` names the global namespace. A
-*nested-name-specifier* that names a namespace [[basic.namespace]],
-optionally followed by the keyword `template` [[temp.names]], and then
-followed by the name of a member of that namespace (or the name of a
-member of a namespace made visible by a *using-directive*), is a
-*qualified-id*;  [[namespace.qual]] describes name lookup for namespace
-members that appear in *qualified-id*s. The result is the member. The
-type of the result is the type of the member. The result is an lvalue if
-the member is a function, a variable, or a structured binding
-[[dcl.struct.bind]] and a prvalue otherwise.
-A *nested-name-specifier* that denotes an enumeration [[dcl.enum]],
-followed by the name of an enumerator of that enumeration, is a
-*qualified-id* that refers to the enumerator. The result is the
-enumerator. The type of the result is the type of the enumeration. The
-result is a prvalue.
-In a *qualified-id*, if the *unqualified-id* is a
-*conversion-function-id*, its *conversion-type-id* is first looked up in
-the class denoted by the *nested-name-specifier* of the *qualified-id*
-and the name, if found, is used. Otherwise, it is looked up in the
-context in which the entire *qualified-id* occurs. In each of these
-lookups, only names that denote types or templates whose specializations
-are types are considered.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
@@ -305,12 +387,12 @@ destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
-[*Note 1*: Such a call ends the lifetime of the object ([[expr.call]],
-[[basic.life]]). — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };
@@ -327,25 +409,45 @@ void f() {
 — *end example*]
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
 ``` bnf
 lambda-expression:
-    lambda-introducer lambda-declaratorₒₚₜ compound-statement
-    lambda-introducer '<' template-parameter-list '>' requires-clauseₒₚₜ lambda-declaratorₒₚₜ compound-statement
 ```
 ``` bnf
 lambda-introducer:
     '[' lambda-captureₒₚₜ ']'
 ```
 ``` bnf
 lambda-declarator:
- '(' parameter-declaration-clause ')' decl-specifier-seqₒₚₜ
- noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ requires-clauseₒₚₜ
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
@@ -365,29 +467,46 @@ A *lambda-expression* is a prvalue whose result object is called the
 *closure object*.
 [*Note 1*: A closure object behaves like a function object
 [[function.objects]]. — *end note*]
-In the *decl-specifier-seq* of the *lambda-declarator*, each
-*decl-specifier* shall be one of `mutable`, `constexpr`, or `consteval`.
-[*Note 2*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
-If a *lambda-expression* does not include a *lambda-declarator*, it is
-as if the *lambda-declarator* were `()`. The lambda return type is
-`auto`, which is replaced by the type specified by the
-*trailing-return-type* if provided and/or deduced from `return`
-statements as described in  [[dcl.spec.auto]].
 [*Example 2*:
 ``` cpp
-auto x1 = [](int i){ return i; }; // OK: return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
-auto x3 = []()->auto&& { return j; }; // OK: return type is int&
 ```
 — *end example*]
 A lambda is a *generic lambda* if the *lambda-expression* has any
@@ -395,12 +514,12 @@ generic parameter type placeholders [[dcl.spec.auto]], or if the lambda
 has a *template-parameter-list*.
 [*Example 3*:
 ``` cpp
-int i = [](int i, auto a) { return i; }(3, 4);                  // OK: a generic lambda
-int j = []<class T>(T t, int i) { return i; }(3, 4);            // OK: a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
@@ -439,56 +558,90 @@ and whose *template-parameter-list* consists of the specified
 call operator template is the *requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
-[*Note 2*: The function call operator template for a generic lambda
-might be an abbreviated function template [[dcl.fct]]. — *end note*]
 [*Example 1*:
 ``` cpp
 auto glambda = [](auto a, auto&& b) { return a < b; };
 bool b = glambda(3, 3.14);                                      // OK
 auto vglambda = [](auto printer) {
-  return [=](auto&& ... ts) {                                   // OK: ts is a function parameter pack
     printer(std::forward<decltype(ts)>(ts)...);
     return [=]() {
       printer(ts ...);
     };
   };
 };
 auto p = vglambda( [](auto v1, auto v2, auto v3)
                    { std::cout << v1 << v2 << v3; } );
-auto q = p(1, 'a', 3.14);                                       // OK: outputs 1a3.14
-q();                                                            // OK: outputs 1a3.14
 ```
 — *end example*]
-The function call operator or operator template is declared `const` (
-[[class.mfct.non-static]]) if and only if the *lambda-expression*’s
-*parameter-declaration-clause* is not followed by `mutable`. It is
 neither virtual nor declared `volatile`. Any *noexcept-specifier*
 specified on a *lambda-expression* applies to the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
-call operator or operator template. The function call operator or any
-given operator template specialization is a constexpr function if either
-the corresponding *lambda-expression*'s *parameter-declaration-clause*
-is followed by `constexpr` or `consteval`, or it satisfies the
-requirements for a constexpr function [[dcl.constexpr]]. It is an
 immediate function [[dcl.constexpr]] if the corresponding
 *lambda-expression*'s *parameter-declaration-clause* is followed by
 `consteval`.
-[*Note 3*: Names referenced in the *lambda-declarator* are looked up in
-the context in which the *lambda-expression* appears. — *end note*]
-[*Example 2*:
 ``` cpp
 auto ID = [](auto a) { return a; };
 static_assert(ID(3) == 3);                      // OK
@@ -499,11 +652,11 @@ struct NonLiteral {
 static_assert(ID(NonLiteral{3}).n == 3);        // error
 ```
 — *end example*]
-[*Example 3*:
 ``` cpp
 auto monoid = [](auto v) { return [=] { return v; }; };
 auto add = [](auto m1) constexpr {
   auto ret = m1();
@@ -528,18 +681,18 @@ static_assert(add(one)(one)() == two());        // error: two() is not a constan
 static_assert(add(one)(one)() == monoid(2)());  // OK
 ```
 — *end example*]
-[*Note 4*:
-The function call operator or operator template may be constrained
 [[temp.constr.decl]] by a *type-constraint* [[temp.param]], a
 *requires-clause* [[temp.pre]], or a trailing *requires-clause*
 [[dcl.decl]].
-[*Example 4*:
 ``` cpp
 template <typename T> concept C1 = ...;
 template <std::size_t N> concept C2 = ...;
 template <typename A, typename B> concept C3 = ...;
@@ -560,27 +713,29 @@ The closure type for a non-generic *lambda-expression* with no
 *lambda-capture* whose constraints (if any) are satisfied has a
 conversion function to pointer to function with C++ language linkage
 [[dcl.link]] having the same parameter and return types as the closure
 type’s function call operator. The conversion is to “pointer to
 `noexcept` function” if the function call operator has a non-throwing
-exception specification. The value returned by this conversion function
-is the address of a function `F` that, when invoked, has the same effect
-as invoking the closure type’s function call operator on a
-default-constructed instance of the closure type. `F` is a constexpr
-function if the function call operator is a constexpr function and is an
-immediate function if the function call operator is an immediate
-function.
 For a generic lambda with no *lambda-capture*, the closure type has a
 conversion function template to pointer to function. The conversion
 function template has the same invented template parameter list, and the
 pointer to function has the same parameter types, as the function call
 operator template. The return type of the pointer to function shall
 behave as if it were a *decltype-specifier* denoting the return type of
 the corresponding function call operator template specialization.
-[*Note 5*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
@@ -612,11 +767,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 5*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -628,45 +783,49 @@ void h(char (*)(int))   { }     // #4
 auto glambda = [](auto a) { return a; };
 f1(glambda);                    // OK
 f2(glambda);                    // error: ID is not convertible
 g(glambda);                     // error: ambiguous
-h(glambda);                     // OK: calls #3 since it is convertible from ID
 int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 ```
 — *end example*]
-The value returned by any given specialization of this conversion
-function template is the address of a function `F` that, when invoked,
-has the same effect as invoking the generic lambda’s corresponding
-function call operator template specialization on a default-constructed
-instance of the closure type. `F` is a constexpr function if the
-corresponding specialization is a constexpr function and `F` is an
-immediate function if the function call operator template specialization
-is an immediate function.
-[*Note 6*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
 parameter types are required to match the return type and parameter
 types of the pointer to function. — *end note*]
-[*Example 6*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
-int (*GL_int)(int) = GL;        // OK: through conversion function template
-GL_int(3);                      // OK: same as GL(3)
 ```
 — *end example*]
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
-[*Example 7*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
@@ -678,18 +837,14 @@ static_assert(Fwd(NC,3) == 3);  // error
 ```
 — *end example*]
 The *lambda-expression*’s *compound-statement* yields the
-*function-body* [[dcl.fct.def]] of the function call operator, but for
-purposes of name lookup [[basic.lookup]], determining the type and value
-of `this` [[class.this]] and transforming *id-expression*s referring to
-non-static class members into class member access expressions using
-`(*this)` ([[class.mfct.non-static]]), the *compound-statement* is
-considered in the context of the *lambda-expression*.
-[*Example 8*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -714,12 +869,12 @@ defaulted default constructor otherwise. It has a defaulted copy
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
-[*Note 7*: These special member functions are implicitly defined as
-usual, and might therefore be defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
 A member of a closure type shall not be explicitly instantiated
@@ -765,13 +920,12 @@ simple-capture:
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
-The body of a *lambda-expression* may refer to variables with automatic
-storage duration and the `*this` object (if any) of enclosing block
-scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
@@ -804,35 +958,37 @@ A *lambda-expression* shall not have a *capture-default* or
 *simple-capture* in its *lambda-introducer* unless its innermost
 enclosing scope is a block scope [[basic.scope.block]] or it appears
 within a default member initializer and its innermost enclosing scope is
 the corresponding class scope [[basic.scope.class]].
-The *identifier* in a *simple-capture* is looked up using the usual
-rules for unqualified name lookup [[basic.lookup.unqual]]; each such
-lookup shall find a local entity. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
-If an *identifier* in a *simple-capture* appears as the *declarator-id*
-of a parameter of the *lambda-declarator*'s
-*parameter-declaration-clause*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
-  auto g = [x](int x) { return 0; };    // error: parameter and simple-capture have the same name
 }
 ```
 — *end example*]
-An *init-capture* without ellipsis behaves as if it declares and
-explicitly captures a variable of the form “`auto` *init-capture* `;`”
-whose declarative region is the *lambda-expression*’s
-*compound-statement*, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
@@ -851,11 +1007,14 @@ int x = 4;
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
-auto z = [a = 42](int a) { return 1; };     // error: parameter and local variable have the same name
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
@@ -869,13 +1028,13 @@ local entities as follows:
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
-If an expression potentially references a local entity within a
-declarative region in which it is odr-usable, and the expression would
-be potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
@@ -886,38 +1045,38 @@ implicit capture of `*this` is deprecated when the *capture-default* is
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
-    f(x);                       // OK: calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
-    f(x);                       // OK: calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
-    f(x, selector);             // OK: captures x, might call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
-Within `g1`, an implementation might optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
-might be implicitly captured even if the expression denoting a local
-entity is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
@@ -933,12 +1092,12 @@ void f(int n) {
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
-entity captured by a *lambda-expression* is odr-used [[basic.def.odr]]
-in the scope containing the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
@@ -948,26 +1107,26 @@ captures an entity that is not odr-usable, the program is ill-formed
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
-      int x[N][M];              // OK: N and M are not odr-used
-      x[0][0] = i;              // OK: i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
-          x += m;               // OK: m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
-          x += f;               // OK: this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
@@ -1030,11 +1189,11 @@ the entity is a reference to an object, an lvalue reference to the
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
-*lambda-expression* that is an odr-use [[basic.def.odr]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
@@ -1050,12 +1209,12 @@ the closure type.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
-    int arr[N];     // OK: not an odr-use, refers to automatic variable
-    f(&N);          // OK: causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
@@ -1103,13 +1262,15 @@ auto h(int &r) {
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
-- if `m1` captures the entity by copy, `m2` captures the corresponding
-  non-static data member of `m1`’s closure type;
-- if `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
@@ -1150,12 +1311,11 @@ captured by reference, invoking the function call operator of the
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
-expansion that introduces an *init-capture* pack [[temp.variadic]] whose
-declarative region is the *lambda-expression*’s *compound-statement*.
 [*Example 12*:
 ``` cpp
 template<class... Args>
@@ -1222,10 +1382,12 @@ bool f(Args ...args) {
 — *end example*]
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
 A *requires-expression* provides a concise way to express requirements
 on template arguments that can be checked by name lookup
 [[basic.lookup]] or by checking properties of types and expressions.
 ``` bnf
@@ -1233,22 +1395,22 @@ requires-expression:
     requires requirement-parameter-listₒₚₜ requirement-body
 ```
 ``` bnf
 requirement-parameter-list:
-    '(' parameter-declaration-clauseₒₚₜ ')'
 ```
 ``` bnf
 requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
     requirement
-    requirement-seq requirement
 ```
 ``` bnf
 requirement:
     simple-requirement
@@ -1257,11 +1419,11 @@ requirement:
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
 described below. Expressions appearing within a *requirement-body* are
-unevaluated operands [[expr.prop]].
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
@@ -1289,13 +1451,11 @@ introduces the *requires-expression*.
 — *end example*]
 A *requires-expression* may introduce local parameters using a
 *parameter-declaration-clause* [[dcl.fct]]. A local parameter of a
-*requires-expression* shall not have a default argument. Each name
-introduced by a local parameter is in scope from the point of its
-declaration until the closing brace of the *requirement-body*. These
 parameters have no linkage, storage, or lifetime; they are only used as
 notation for the purpose of defining *requirement*s. The
 *parameter-declaration-clause* of a *requirement-parameter-list* shall
 not terminate with an ellipsis.
@@ -1308,14 +1468,10 @@ concept C = requires(T t, ...) {    // error: terminates with an ellipsis
 };
 ```
 — *end example*]
-The *requirement-body* contains a sequence of *requirement*s. These
-*requirement*s may refer to local parameters, template parameters, and
-any other declarations visible from the enclosing context.
 The substitution of template arguments into a *requires-expression* may
 result in the formation of invalid types or expressions in its
 *requirement*s or the violation of the semantic constraints of those
 *requirement*s. In such cases, the *requires-expression* evaluates to
 `false`; it does not cause the program to be ill-formed. The
@@ -1354,11 +1510,12 @@ simple-requirement:
 A *simple-requirement* asserts the validity of an *expression*.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments into the *expression* fails. The
-*expression* is an unevaluated operand [[expr.prop]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
@@ -1393,19 +1550,20 @@ if substitution of template arguments fails. — *end note*]
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;    // required nested member name
-  typename S<T>;        // required class template specialization
   typename Ref<T>;      // required alias template substitution, fails if T is void
 };
 ```
 — *end example*]
 A *type-requirement* that names a class template specialization does not
-require that type to be complete [[basic.types]].
 #### Compound requirements <a id="expr.prim.req.compound">[[expr.prim.req.compound]]</a>
 ``` bnf
 compound-requirement:
@@ -1428,10 +1586,11 @@ properties proceed in the following order:
 - If the *return-type-requirement* is present, then:
   - Substitution of template arguments (if any) into the
     *return-type-requirement* is performed.
   - The immediately-declared constraint [[temp.param]] of the
     *type-constraint* for `decltype((E))` shall be satisfied.
   \[*Example 1*:
   Given concepts `C` and `D`,
   ``` cpp
   requires {
     { E1 } -> C;
@@ -1510,19 +1669,5 @@ template<typename T> concept D = requires (T t) {
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]
-A local parameter shall only appear as an unevaluated operand
-[[expr.prop]] within the *constraint-expression*.
-[*Example 2*:
-``` cpp
-template<typename T> concept C = requires (T a) {
-  requires sizeof(a) == 4;      // OK
-  requires a == 0;              // error: evaluation of a constraint variable
-};
-```
-— *end example*]

     requires-expression
 ```
 ### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
+The type of a *literal* is determined based on its form as specified in
+[[lex.literal]]. A *string-literal* is an lvalue designating a
+corresponding string literal object [[lex.string]], a
+*user-defined-literal* has the same value category as the corresponding
+operator call expression described in [[lex.ext]], and any other
+*literal* is a prvalue.
 ### This <a id="expr.prim.this">[[expr.prim.this]]</a>
+The keyword `this` names a pointer to the object for which an implicit
+object member function [[class.mfct.non.static]] is invoked or a
+non-static data member’s initializer [[class.mem]] is evaluated.
+The *current class* at a program point is the class associated with the
+innermost class scope containing that point.
+[*Note 1*: A *lambda-expression* does not introduce a class
+scope. — *end note*]
 If a declaration declares a member function or member function template
 of a class `X`, the expression `this` is a prvalue of type “pointer to
+*cv-qualifier-seq* `X`” wherever `X` is the current class between the
+optional *cv-qualifier-seq* and the end of the *function-definition*,
+*member-declarator*, or *declarator*. It shall not appear within the
+declaration of either a static member function or an explicit object
+member function of the current class (although its type and value
+category are defined within such member functions as they are within an
+implicit object member function).
+[*Note 2*: This is because declaration matching does not occur until
 the complete declarator is known. — *end note*]
+[*Note 3*:
 In a *trailing-return-type*, the class being defined is not required to
 be complete for purposes of class member access [[expr.ref]]. Class
 members declared later are not visible.
 — *end note*]
 Otherwise, if a *member-declarator* declares a non-static data member
 [[class.mem]] of a class `X`, the expression `this` is a prvalue of type
+“pointer to `X`” wherever `X` is the current class within the optional
+default member initializer [[class.mem]].
 The expression `this` shall not appear in any other context.
 [*Example 2*:
 ``` cpp
 class Outer {
   int a[sizeof(*this)];                 // error: not inside a member function
+  unsigned int sz = sizeof(*this);      // OK, in default member initializer
   void f() {
     int b[sizeof(*this)];               // OK
     struct Inner {
 — *end example*]
 ### Parentheses <a id="expr.prim.paren">[[expr.prim.paren]]</a>
 A parenthesized expression `(E)` is a primary expression whose type,
+result, and value category are identical to those of E. The
+parenthesized expression can be used in exactly the same contexts as
+those where E can be used, and with the same meaning, except as
+otherwise indicated.
 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
+#### General <a id="expr.prim.id.general">[[expr.prim.id.general]]</a>
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
+If an *id-expression* E denotes a member M of an anonymous union
+[[class.union.anon]] U:
+- If U is a non-static data member, E refers to M as a member of the
+  lookup context of the terminal name of E (after any transformation to
+  a class member access expression [[class.mfct.non.static]]).
+  \[*Example 1*: `o.x` is interpreted as `o.u.x`, where u names the
+  anonymous union member. — *end example*]
+- Otherwise, E is interpreted as a class member access [[expr.ref]] that
+  designates the member subobject M of the anonymous union variable for
+  U. \[*Note 2*: Under this interpretation, E no longer denotes a
+  non-static data member. — *end note*] \[*Example 2*: `N::x` is
+  interpreted as `N::u.x`, where u names the anonymous union
+  variable. — *end example*]
+An *id-expression* that denotes a non-static data member or implicit
+object member function of a class can only be used:
 - as part of a class member access [[expr.ref]] in which the object
   expression refers to the member’s class[^10] or a class derived from
   that class, or
 - to form a pointer to member [[expr.unary.op]], or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
+  \[*Example 3*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
+is performed to select a unique function [[over.match]], [[over.over]].
+[*Note 3*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
+[*Example 4*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
+};
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
 declaration of `p2`, those constraints are required to be satisfied even
+though `f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
 [[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
 denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
 Within the definition of a non-static member function, an *identifier*
 that names a non-static member is transformed to a class member access
+expression [[class.mfct.non.static]]. — *end note*]
+A *component name* of an *unqualified-id* U is
+- U if it is a name or
+- the component name of the *template-id* or *type-name* of U, if any.
+[*Note 2*: Other constructs that contain names to look up can have
+several component names
+[[expr.prim.id.qual]], [[dcl.type.simple]], [[dcl.type.elab]], [[dcl.mptr]], [[namespace.udecl]], [[temp.param]], [[temp.names]], [[temp.res]]. — *end note*]
+The *terminal name* of a construct is the component name of that
+construct that appears lexically last.
+The result is the entity denoted by the *unqualified-id*
+[[basic.lookup.unqual]]. If the *unqualified-id* appears in a
+*lambda-expression* at program point P and the entity is a local entity
+[[basic.pre]] or a variable declared by an *init-capture*
+[[expr.prim.lambda.capture]], then let S be the *compound-statement* of
+the innermost enclosing *lambda-expression* of P. If naming the entity
+from outside of an unevaluated operand within S would refer to an entity
+captured by copy in some intervening *lambda-expression*, then let E be
+the innermost such *lambda-expression*.
+- If there is such a *lambda-expression* and if P is in E’s function
+  parameter scope but not its *parameter-declaration-clause*, then the
+  type of the expression is the type of a class member access expression
+  [[expr.ref]] naming the non-static data member that would be declared
+  for such a capture in the object parameter [[dcl.fct]] of the function
+  call operator of E. \[*Note 3*: If E is not declared `mutable`, the
   type of such an identifier will typically be `const`
   qualified. — *end note*]
+- Otherwise (if there is no such *lambda-expression* or if P either
+  precedes E’s function parameter scope or is in E’s
+  *parameter-declaration-clause*), the type of the expression is the
+  type of the result.
+[*Note 4*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
 `const T`. — *end note*]
+[*Note 5*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
+The expression is an xvalue if it is move-eligible (see below); an
+lvalue if the entity is a function, variable, structured binding
+[[dcl.struct.bind]], data member, or template parameter object; and a
+prvalue otherwise [[basic.lval]]; it is a bit-field if the identifier
+designates a bit-field.
 [*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
+  [=]() -> decltype((x)) {      // lambda returns float const& because this lambda is not mutable and
+                                // x is an lvalue
     decltype(x) y1;             // y1 has type float
+    decltype((x)) y2 = y1;      // y2 has type float const&
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
+    return y2;
+  };
+  [=](decltype((x)) y) {
+    decltype((x)) z = x;        // OK, y has type float&, z has type float const&
+  };
+  [=] {
+    [](decltype((x)) y) {};     // OK, lambda takes a parameter of type float const&
+    [x=1](decltype((x)) y) {
+      decltype((x)) z = x;      // OK, y has type int&, z has type int const&
+    };
   };
 }
 ```
 — *end example*]
+An *implicitly movable entity* is a variable of automatic storage
+duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. In the following contexts, an
+*id-expression* is *move-eligible*:
+- If the *id-expression* (possibly parenthesized) is the operand of a
+  `return` [[stmt.return]] or `co_return` [[stmt.return.coroutine]]
+  statement, and names an implicitly movable entity declared in the body
+  or *parameter-declaration-clause* of the innermost enclosing function
+  or *lambda-expression*, or
+- if the *id-expression* (possibly parenthesized) is the operand of a
+  *throw-expression* [[expr.throw]], and names an implicitly movable
+  entity that belongs to a scope that does not contain the
+  *compound-statement* of the innermost *lambda-expression*,
+  *try-block*, or *function-try-block* (if any) whose
+  *compound-statement* or *ctor-initializer* contains the
+  *throw-expression*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier templateₒₚₜ unqualified-id
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
+The component names of a *qualified-id* are those of its
+*nested-name-specifier* and *unqualified-id*. The component names of a
+*nested-name-specifier* are its *identifier* (if any) and those of its
+*type-name*, *namespace-name*, *simple-template-id*, and/or
+*nested-name-specifier*.
+A *nested-name-specifier* is *declarative* if it is part of
+- a *class-head-name*,
+- an *enum-head-name*,
+- a *qualified-id* that is the *id-expression* of a *declarator-id*, or
+- a declarative *nested-name-specifier*.
+A declarative *nested-name-specifier* shall not have a
+*decltype-specifier*. A declaration that uses a declarative
+*nested-name-specifier* shall be a friend declaration or inhabit a scope
+that contains the entity being redeclared or specialized.
+The *nested-name-specifier* `::` nominates the global namespace. A
+*nested-name-specifier* with a *decltype-specifier* nominates the type
+denoted by the *decltype-specifier*, which shall be a class or
+enumeration type. If a *nested-name-specifier* N is declarative and has
+a *simple-template-id* with a template argument list A that involves a
+template parameter, let T be the template nominated by N without A. T
+shall be a class template.
+- If A is the template argument list [[temp.arg]] of the corresponding
+  *template-head* H [[temp.mem]], N nominates the primary template of T;
+  H shall be equivalent to the *template-head* of T [[temp.over.link]].
+- Otherwise, N nominates the partial specialization
+  [[temp.spec.partial]] of T whose template argument list is equivalent
+  to A [[temp.over.link]]; the program is ill-formed if no such partial
+  specialization exists.
+Any other *nested-name-specifier* nominates the entity denoted by its
+*type-name*, *namespace-name*, *identifier*, or *simple-template-id*. If
+the *nested-name-specifier* is not declarative, the entity shall not be
+a template.
+A *qualified-id* shall not be of the form *nested-name-specifier*
+`template`ₒₚₜ  `~` *decltype-specifier* nor of the form
+*decltype-specifier* `::` `~` *type-name*.
+The result of a *qualified-id* Q is the entity it denotes
+[[basic.lookup.qual]]. The type of the expression is the type of the
+result. The result is an lvalue if the member is
+- a function other than a non-static member function,
+- a non-static member function if Q is the operand of a unary `&`
+  operator,
+- a variable,
+- a structured binding [[dcl.struct.bind]], or
+- a data member,
 and a prvalue otherwise.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
+[*Note 1*: Such a call ends the lifetime of the object
+[[expr.call]], [[basic.life]]. — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };
 — *end example*]
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
+#### General <a id="expr.prim.lambda.general">[[expr.prim.lambda.general]]</a>
 ``` bnf
 lambda-expression:
+    lambda-introducer attribute-specifier-seqₒₚₜ lambda-declarator compound-statement
+    lambda-introducer '<' template-parameter-list '>' requires-clauseₒₚₜ attribute-specifier-seqₒₚₜ
+       lambda-declarator compound-statement
 ```
 ``` bnf
 lambda-introducer:
     '[' lambda-captureₒₚₜ ']'
 ```
 ``` bnf
 lambda-declarator:
+ lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
+ noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
+    trailing-return-typeₒₚₜ
+    '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+       trailing-return-typeₒₚₜ requires-clauseₒₚₜ
+```
+``` bnf
+lambda-specifier:
+    consteval
+    constexpr
+    mutable
+    static
+```
+``` bnf
+lambda-specifier-seq:
+    lambda-specifier
+    lambda-specifier lambda-specifier-seq
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
 *closure object*.
 [*Note 1*: A closure object behaves like a function object
 [[function.objects]]. — *end note*]
+An ambiguity can arise because a *requires-clause* can end in an
+*attribute-specifier-seq*, which collides with the
+*attribute-specifier-seq* in *lambda-expression*. In such cases, any
+attributes are treated as *attribute-specifier-seq* in
+*lambda-expression*.
+[*Note 2*: Such ambiguous cases cannot have valid semantics because the
+constraint expression would not have type `bool`. — *end note*]
+A *lambda-specifier-seq* shall contain at most one of each
+*lambda-specifier* and shall not contain both `constexpr` and
+`consteval`. If the *lambda-declarator* contains an explicit object
+parameter [[dcl.fct]], then no *lambda-specifier* in the
+*lambda-specifier-seq* shall be `mutable` or `static`. The
+*lambda-specifier-seq* shall not contain both `mutable` and `static`. If
+the *lambda-specifier-seq* contains `static`, there shall be no
+*lambda-capture*.
+[*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
+If a *lambda-declarator* does not include a
+*parameter-declaration-clause*, it is as if `()` were inserted at the
+start of the *lambda-declarator*. If the *lambda-declarator* does not
+include a *trailing-return-type*, it is considered to be `-> auto`.
+[*Note 4*: In that case, the return type is deduced from `return`
+statements as described in [[dcl.spec.auto]]. — *end note*]
 [*Example 2*:
 ``` cpp
+auto x1 = [](int i) { return i; }; // OK, return type is int
 auto x2 = []{ return { 1, 2 }; };       // error: deducing return type from braced-init-list
 int j;
+auto x3 = [&]()->auto&& { return j; }; // OK, return type is int&
 ```
 — *end example*]
 A lambda is a *generic lambda* if the *lambda-expression* has any
 has a *template-parameter-list*.
 [*Example 3*:
 ``` cpp
+int i = [](int i, auto a) { return i; }(3, 4);                  // OK, a generic lambda
+int j = []<class T>(T t, int i) { return i; }(3, 4);            // OK, a generic lambda
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 call operator template is the *requires-clause* immediately following
 `<` *template-parameter-list* `>`, if any. The trailing
 *requires-clause* of the function call operator or operator template is
 the *requires-clause* of the *lambda-declarator*, if any.
+[*Note 2*: The function call operator template for a generic lambda can
+be an abbreviated function template [[dcl.fct]]. — *end note*]
 [*Example 1*:
 ``` cpp
 auto glambda = [](auto a, auto&& b) { return a < b; };
 bool b = glambda(3, 3.14);                                      // OK
 auto vglambda = [](auto printer) {
+  return [=](auto&& ... ts) {                                   // OK, ts is a function parameter pack
     printer(std::forward<decltype(ts)>(ts)...);
     return [=]() {
       printer(ts ...);
     };
   };
 };
 auto p = vglambda( [](auto v1, auto v2, auto v3)
                    { std::cout << v1 << v2 << v3; } );
+auto q = p(1, 'a', 3.14);                                       // OK, outputs 1a3.14
+q();                                                            // OK, outputs 1a3.14
+auto fact = [](this auto self, int n) -> int {                  // OK, explicit object parameter
+  return (n <= 1) ? 1 : n * self(n-1);
+};
+std::cout << fact(5);                                           // OK, outputs 120
+```
+— *end example*]
+Given a lambda with a *lambda-capture*, the type of the explicit object
+parameter, if any, of the lambda’s function call operator (possibly
+instantiated from a function call operator template) shall be either:
+- the closure type,
+- a class type derived from the closure type, or
+- a reference to a possibly cv-qualified such type.
+[*Example 2*:
+``` cpp
+struct C {
+  template <typename T>
+  C(T);
+};
+void func(int i) {
+  int x = [=](this auto&&) { return i; }();     // OK
+  int y = [=](this C) { return i; }();          // error
+  int z = [](this C) { return 42; }();          // OK
+}
 ```
 — *end example*]
+The function call operator or operator template is a static member
+function or static member function template [[class.static.mfct]] if the
+*lambda-expression*’s *parameter-declaration-clause* is followed by
+`static`. Otherwise, it is a non-static member function or member
+function template [[class.mfct.non.static]] that is declared `const`
+[[class.mfct.non.static]] if and only if the *lambda-expression*’s
+*parameter-declaration-clause* is not followed by `mutable` and the
+*lambda-declarator* does not contain an explicit object parameter. It is
 neither virtual nor declared `volatile`. Any *noexcept-specifier*
 specified on a *lambda-expression* applies to the corresponding function
 call operator or operator template. An *attribute-specifier-seq* in a
 *lambda-declarator* appertains to the type of the corresponding function
+call operator or operator template. An *attribute-specifier-seq* in a
+*lambda-expression* preceding a *lambda-declarator* appertains to the
+corresponding function call operator or operator template. The function
+call operator or any given operator template specialization is a
+constexpr function if either the corresponding *lambda-expression*'s
+*parameter-declaration-clause* is followed by `constexpr` or
+`consteval`, or it is constexpr-suitable [[dcl.constexpr]]. It is an
 immediate function [[dcl.constexpr]] if the corresponding
 *lambda-expression*'s *parameter-declaration-clause* is followed by
 `consteval`.
+[*Example 3*:
 ``` cpp
 auto ID = [](auto a) { return a; };
 static_assert(ID(3) == 3);                      // OK
 static_assert(ID(NonLiteral{3}).n == 3);        // error
 ```
 — *end example*]
+[*Example 4*:
 ``` cpp
 auto monoid = [](auto v) { return [=] { return v; }; };
 auto add = [](auto m1) constexpr {
   auto ret = m1();
 static_assert(add(one)(one)() == monoid(2)());  // OK
 ```
 — *end example*]
+[*Note 3*:
+The function call operator or operator template can be constrained
 [[temp.constr.decl]] by a *type-constraint* [[temp.param]], a
 *requires-clause* [[temp.pre]], or a trailing *requires-clause*
 [[dcl.decl]].
+[*Example 5*:
 ``` cpp
 template <typename T> concept C1 = ...;
 template <std::size_t N> concept C2 = ...;
 template <typename A, typename B> concept C3 = ...;
 *lambda-capture* whose constraints (if any) are satisfied has a
 conversion function to pointer to function with C++ language linkage
 [[dcl.link]] having the same parameter and return types as the closure
 type’s function call operator. The conversion is to “pointer to
 `noexcept` function” if the function call operator has a non-throwing
+exception specification. If the function call operator is a static
+member function, then the value returned by this conversion function is
+the address of the function call operator. Otherwise, the value returned
+by this conversion function is the address of a function `F` that, when
+invoked, has the same effect as invoking the closure type’s function
+call operator on a default-constructed instance of the closure type. `F`
+is a constexpr function if the function call operator is a constexpr
+function and is an immediate function if the function call operator is
+an immediate function.
 For a generic lambda with no *lambda-capture*, the closure type has a
 conversion function template to pointer to function. The conversion
 function template has the same invented template parameter list, and the
 pointer to function has the same parameter types, as the function call
 operator template. The return type of the pointer to function shall
 behave as if it were a *decltype-specifier* denoting the return type of
 the corresponding function call operator template specialization.
+[*Note 4*:
 If the generic lambda has no *trailing-return-type* or the
 *trailing-return-type* contains a placeholder type, return type
 deduction of the corresponding function call operator template
 specialization has to be done. The corresponding specialization is that
 };
 ```
 — *end note*]
+[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 auto glambda = [](auto a) { return a; };
 f1(glambda);                    // OK
 f2(glambda);                    // error: ID is not convertible
 g(glambda);                     // error: ambiguous
+h(glambda);                     // OK, calls #3 since it is convertible from ID
 int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; };        // OK
 ```
 — *end example*]
+If the function call operator template is a static member function
+template, then the value returned by any given specialization of this
+conversion function template is the address of the corresponding
+function call operator template specialization. Otherwise, the value
+returned by any given specialization of this conversion function
+template is the address of a function `F` that, when invoked, has the
+same effect as invoking the generic lambda’s corresponding function call
+operator template specialization on a default-constructed instance of
+the closure type. `F` is a constexpr function if the corresponding
+specialization is a constexpr function and `F` is an immediate function
+if the function call operator template specialization is an immediate
+function.
+[*Note 5*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
 parameter types are required to match the return type and parameter
 types of the pointer to function. — *end note*]
+[*Example 7*:
 ``` cpp
 auto GL = [](auto a) { std::cout << a; return a; };
+int (*GL_int)(int) = GL;        // OK, through conversion function template
+GL_int(3);                      // OK, same as GL(3)
 ```
 — *end example*]
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing
 exception specification [[except.spec]].
+[*Example 8*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 ```
 — *end example*]
 The *lambda-expression*’s *compound-statement* yields the
+*function-body* [[dcl.fct.def]] of the function call operator, but it is
+not within the scope of the closure type.
+[*Example 9*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
 constructor and a defaulted move constructor [[class.copy.ctor]]. It has
 a deleted copy assignment operator if the *lambda-expression* has a
 *lambda-capture* and defaulted copy and move assignment operators
 otherwise [[class.copy.assign]].
+[*Note 6*: These special member functions are implicitly defined as
+usual, which can result in them being defined as deleted. — *end note*]
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor [[class.dtor]].
 A member of a closure type shall not be explicitly instantiated
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
+The body of a *lambda-expression* may refer to local entities of
+enclosing block scopes by capturing those entities, as described below.
 If a *lambda-capture* includes a *capture-default* that is `&`, no
 identifier in a *simple-capture* of that *lambda-capture* shall be
 preceded by `&`. If a *lambda-capture* includes a *capture-default* that
 is `=`, each *simple-capture* of that *lambda-capture* shall be of the
 *simple-capture* in its *lambda-introducer* unless its innermost
 enclosing scope is a block scope [[basic.scope.block]] or it appears
 within a default member initializer and its innermost enclosing scope is
 the corresponding class scope [[basic.scope.class]].
+The *identifier* in a *simple-capture* shall denote a local entity
+[[basic.lookup.unqual]], [[basic.pre]]. The *simple-capture*s `this` and
 `* this` denote the local entity `*this`. An entity that is designated
 by a *simple-capture* is said to be *explicitly captured*.
+If an *identifier* in a *capture* appears as the *declarator-id* of a
+parameter of the *lambda-declarator*’s *parameter-declaration-clause* or
+as the name of a template parameter of the *lambda-expression*’s
+*template-parameter-list*, the program is ill-formed.
 [*Example 2*:
 ``` cpp
 void f() {
   int x = 0;
+  auto g = [x](int x) { return 0; };    // error: parameter and capture have the same name
+  auto h = [y = 0]<typename y>(y) { return 0; };    // error: template parameter and capture
+                                                    // have the same name
 }
 ```
 — *end example*]
+An *init-capture* inhabits the lambda scope [[basic.scope.lambda]] of
+the *lambda-expression*. An *init-capture* without ellipsis behaves as
+if it declares and explicitly captures a variable of the form “`auto`
+*init-capture* `;`”, except that:
 - if the capture is by copy (see below), the non-static data member
   declared for the capture and the variable are treated as two different
   ways of referring to the same object, which has the lifetime of the
   non-static data member, and no additional copy and destruction is
 auto y = [&r = x, x = x+1]()->int {
             r += 2;
             return x+2;
          }();                               // Updates ::x to 6, and initializes y to 7.
+auto z = [a = 42](int a) { return 1; };     // error: parameter and conceptual local variable have the same name
+auto counter = [i=0]() mutable -> decltype(i) {     // OK, returns int
+  return i++;
+};
 ```
 — *end example*]
 For the purposes of lambda capture, an expression potentially references
   *id-expression*. — *end note*]
 - A `this` expression potentially references `*this`.
 - A *lambda-expression* potentially references the local entities named
   by its *simple-capture*s.
+If an expression potentially references a local entity within a scope in
+which it is odr-usable [[basic.def.odr]], and the expression would be
+potentially evaluated if the effect of any enclosing `typeid`
 expressions [[expr.typeid]] were ignored, the entity is said to be
 *implicitly captured* by each intervening *lambda-expression* with an
 associated *capture-default* that does not explicitly capture it. The
 implicit capture of `*this` is deprecated when the *capture-default* is
 `=`; see [[depr.capture.this]].
 void f(int, const int (&)[2] = {});         // #1
 void f(const int&, const int (&)[1]);       // #2
 void test() {
   const int x = 17;
   auto g = [](auto a) {
+    f(x);                       // OK, calls #1, does not capture x
   };
   auto g1 = [=](auto a) {
+    f(x);                       // OK, calls #1, captures x
   };
   auto g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
+    f(x, selector);             // OK, captures x, can call #1 or #2
   };
   auto g3 = [=](auto a) {
     typeid(a + x);              // captures x regardless of whether a + x is an unevaluated operand
   };
 }
 ```
+Within `g1`, an implementation can optimize away the capture of `x` as
 it is not odr-used.
 — *end example*]
 [*Note 4*:
 The set of captured entities is determined syntactically, and entities
+are implicitly captured even if the expression denoting a local entity
+is within a discarded statement [[stmt.if]].
 [*Example 5*:
 ``` cpp
 template<bool B>
 — *end example*]
 — *end note*]
 An entity is *captured* if it is captured explicitly or implicitly. An
+entity captured by a *lambda-expression* is odr-used [[term.odr.use]] by
+the *lambda-expression*.
 [*Note 5*: As a consequence, if a *lambda-expression* explicitly
 captures an entity that is not odr-usable, the program is ill-formed
 [[basic.def.odr]]. — *end note*]
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
+      int x[N][M];              // OK, N and M are not odr-used
+      x[0][0] = i;              // OK, i is explicitly captured by m2 and implicitly captured by m1
     };
   };
   struct s1 {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
         auto m4 = [&,j] {       // error: j not odr-usable due to intervening lambda m3
           int x = n;            // error: n is odr-used but not odr-usable due to intervening lambda m3
+          x += m;               // OK, m implicitly captured by m4 and explicitly captured by m3
           x += i;               // error: i is odr-used but not odr-usable
                                 // due to intervening function and class scopes
+          x += f;               // OK, this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
 }
 referenced function type if the entity is a reference to a function, or
 the type of the corresponding captured entity otherwise. A member of an
 anonymous union shall not be captured by copy.
 Every *id-expression* within the *compound-statement* of a
+*lambda-expression* that is an odr-use [[term.odr.use]] of an entity
 captured by copy is transformed into an access to the corresponding
 unnamed data member of the closure type.
 [*Note 7*: An *id-expression* that is not an odr-use refers to the
 original entity, never to a member of the closure type. However, such an
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
+    int arr[N];     // OK, not an odr-use, refers to automatic variable
+    f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
+- If `m1` captures the entity by copy, `m2` captures the corresponding
+  non-static data member of `m1`’s closure type; if `m1` is not
+ `mutable`, the non-static data member is considered to be
+  const-qualified.
+- If `m1` captures the entity by reference, `m2` captures the same
   entity captured by `m1`.
 [*Example 11*:
 The nested *lambda-expression*s and invocations below will output
 corresponding *lambda-expression* after the lifetime of the entity has
 ended is likely to result in undefined behavior. — *end note*]
 A *simple-capture* containing an ellipsis is a pack expansion
 [[temp.variadic]]. An *init-capture* containing an ellipsis is a pack
+expansion that declares an *init-capture* pack [[temp.variadic]].
 [*Example 12*:
 ``` cpp
 template<class... Args>
 — *end example*]
 ### Requires expressions <a id="expr.prim.req">[[expr.prim.req]]</a>
+#### General <a id="expr.prim.req.general">[[expr.prim.req.general]]</a>
 A *requires-expression* provides a concise way to express requirements
 on template arguments that can be checked by name lookup
 [[basic.lookup]] or by checking properties of types and expressions.
 ``` bnf
     requires requirement-parameter-listₒₚₜ requirement-body
 ```
 ``` bnf
 requirement-parameter-list:
+    '(' parameter-declaration-clause ')'
 ```
 ``` bnf
 requirement-body:
     '{' requirement-seq '}'
 ```
 ``` bnf
 requirement-seq:
     requirement
+    requirement requirement-seq
 ```
 ``` bnf
 requirement:
     simple-requirement
     nested-requirement
 ```
 A *requires-expression* is a prvalue of type `bool` whose value is
 described below. Expressions appearing within a *requirement-body* are
+unevaluated operands [[term.unevaluated.operand]].
 [*Example 1*:
 A common use of *requires-expression*s is to define requirements in
 concepts such as the one below:
 — *end example*]
 A *requires-expression* may introduce local parameters using a
 *parameter-declaration-clause* [[dcl.fct]]. A local parameter of a
+*requires-expression* shall not have a default argument. These
 parameters have no linkage, storage, or lifetime; they are only used as
 notation for the purpose of defining *requirement*s. The
 *parameter-declaration-clause* of a *requirement-parameter-list* shall
 not terminate with an ellipsis.
 };
 ```
 — *end example*]
 The substitution of template arguments into a *requires-expression* may
 result in the formation of invalid types or expressions in its
 *requirement*s or the violation of the semantic constraints of those
 *requirement*s. In such cases, the *requires-expression* evaluates to
 `false`; it does not cause the program to be ill-formed. The
 A *simple-requirement* asserts the validity of an *expression*.
 [*Note 1*: The enclosing *requires-expression* will evaluate to `false`
 if substitution of template arguments into the *expression* fails. The
+*expression* is an unevaluated operand
+[[term.unevaluated.operand]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename T> concept C =
 template<typename T, typename T::type = 0> struct S;
 template<typename T> using Ref = T&;
 template<typename T> concept C = requires {
   typename T::inner;    // required nested member name
+  typename S<T>;        // required valid[temp.names] template-id;
+                        // fails if T::type does not exist as a type to which 0 can be implicitly converted
   typename Ref<T>;      // required alias template substitution, fails if T is void
 };
 ```
 — *end example*]
 A *type-requirement* that names a class template specialization does not
+require that type to be complete [[term.incomplete.type]].
 #### Compound requirements <a id="expr.prim.req.compound">[[expr.prim.req.compound]]</a>
 ``` bnf
 compound-requirement:
 - If the *return-type-requirement* is present, then:
   - Substitution of template arguments (if any) into the
     *return-type-requirement* is performed.
   - The immediately-declared constraint [[temp.param]] of the
     *type-constraint* for `decltype((E))` shall be satisfied.
   \[*Example 1*:
   Given concepts `C` and `D`,
   ``` cpp
   requires {
     { E1 } -> C;
 `D<T>` is satisfied if `sizeof(decltype (+t)) == 1`
 [[temp.constr.atomic]].
 — *end example*]

Diff to HTML by rtfpessoa