[expr.prim.lambda] - C++17 → C++20

Files changed (1) hide show

tmp/tmpm825b934/{from.md → to.md} +278 -214

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

@@ -1,25 +1,26 @@
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
 ``` bnf
 lambda-expression:
     lambda-introducer 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ₒₚₜ
 ```
-Lambda expressions provide a concise way to create simple function
-objects.
 [*Example 1*:
 ``` cpp
 #include <algorithm>
@@ -30,24 +31,20 @@ void abssort(float* x, unsigned N) {
 ```
 — *end example*]
 A *lambda-expression* is a prvalue whose result object is called the
-*closure object*. A *lambda-expression* shall not appear in an
-unevaluated operand (Clause  [[expr]]), in a *template-argument*, in an
-*alias-declaration*, in a typedef declaration, or in the declaration of
-a function or function template outside its function body and default
-arguments.
-[*Note 1*: The intention is to prevent lambdas from appearing in a
-signature. — *end note*]
-[*Note 2*: 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 either be `mutable` or `constexpr`.
 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`
@@ -62,54 +59,63 @@ int j;
 auto x3 = []()->auto&& { return j; };   // OK: return type is int&
 ```
 — *end example*]
 #### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
-with the closure type ([[basic.lookup.argdep]]). The parameter types of
-a *lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
-The closure type is not an aggregate type ([[dcl.init.aggr]]). An
 implementation may define the closure type differently from what is
 described below provided this does not alter the observable behavior of
 the program other than by changing:
 - the size and/or alignment of the closure type,
-- whether the closure type is trivially copyable (Clause  [[class]]),
-- whether the closure type is a standard-layout class (Clause
-  [[class]]), or
-- whether the closure type is a POD class (Clause  [[class]]).
 An implementation shall not add members of rvalue reference type to the
 closure type.
-The closure type for a non-generic *lambda-expression* has a public
-inline function call operator ([[over.call]]) whose parameters and
 return type are described by the *lambda-expression*’s
-*parameter-declaration-clause* and *trailing-return-type* respectively.
-For a generic lambda, the closure type has a public inline function call
-operator member template ([[temp.mem]]) whose *template-parameter-list*
-consists of one invented type *template-parameter* for each occurrence
-of `auto` in the lambda’s *parameter-declaration-clause*, in order of
-appearance. The invented type *template-parameter* is a parameter pack
-if the corresponding *parameter-declaration* declares a function
-parameter pack ([[dcl.fct]]). The return type and function parameters
-of the function call operator template are derived from the
-*lambda-expression*'s *trailing-return-type* and
-*parameter-declaration-clause* by replacing each occurrence of `auto` in
-the *decl-specifier*s of the *parameter-declaration-clause* with the
-name of the corresponding invented *template-parameter*.
 [*Example 1*:
 ``` cpp
 auto glambda = [](auto a, auto&& b) { return a < b; };
@@ -140,14 +146,17 @@ 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 it satisfies the requirements for a
-constexpr function ([[dcl.constexpr]]).
-[*Note 2*: Names referenced in the *lambda-declarator* are looked up in
 the context in which the *lambda-expression* appears. — *end note*]
 [*Example 2*:
 ``` cpp
@@ -156,11 +165,11 @@ static_assert(ID(3) == 3); // OK
 struct NonLiteral {
   NonLiteral(int n) : n(n) { }
   int n;
 };
-static_assert(ID(NonLiteral{3}).n == 3); // ill-formed
 ```
 — *end example*]
 [*Example 3*:
@@ -184,35 +193,65 @@ static_assert(add(one)(zero)() == one()); // OK
 // Since two below is not declared constexpr, an evaluation of its constexpr member function call operator
 // cannot perform an lvalue-to-rvalue conversion on one of its subobjects (that represents its capture)
 // in a constant expression.
 auto two = monoid(2);
 assert(two() == 2); // OK, not a constant expression.
-static_assert(add(one)(one)() == two()); // ill-formed: two() is not a constant expression
 static_assert(add(one)(one)() == monoid(2)());  // OK
 ```
 — *end example*]
 The closure type for a non-generic *lambda-expression* with no
-*lambda-capture* 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. `F` is a constexpr function if the function call operator is a
-constexpr 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 3*:
 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
@@ -244,11 +283,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 4*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -269,19 +308,22 @@ 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. `F` is a constexpr
-function if the corresponding specialization is a constexpr function.
-[*Note 4*: This will result in the implicit instantiation of the
 generic lambda’s body. The instantiated generic lambda’s return type and
-parameter types shall match the return type and parameter types of the
-pointer to function. — *end note*]
-[*Example 5*:
 ``` 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)
@@ -289,37 +331,36 @@ 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 6*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 static_assert(Fwd(C,3) == 3);   // OK
 // No specialization of the function call operator template can be constexpr (due to the local static).
 auto NC = [](auto a) { static int s; return a; };
-static_assert(Fwd(NC,3) == 3); // ill-formed
 ```
 — *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 7*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
@@ -337,22 +378,26 @@ struct S1 {
 Further, a variable `__func__` is implicitly defined at the beginning of
 the *compound-statement* of the *lambda-expression*, with semantics as
 described in  [[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
-constructor and a deleted copy assignment operator. It has a defaulted
-copy constructor and a defaulted move constructor ([[class.copy]]).
-[*Note 5*: 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 (
-[[temp.explicit]]), explicitly specialized ([[temp.expl.spec]]), or
-named in a `friend` declaration ([[class.friend]]).
 #### Captures <a id="expr.prim.lambda.capture">[[expr.prim.lambda.capture]]</a>
 ``` bnf
 lambda-capture:
@@ -367,43 +412,43 @@ capture-default:
     '='
 ```
 ``` bnf
 capture-list:
-    capture '...'ₒₚₜ
-    capture-list ',' capture '...'ₒₚₜ
 ```
 ``` bnf
 capture:
     simple-capture
     init-capture
 ```
 ``` bnf
 simple-capture:
-    identifier
-    '&' identifier
- 'this'
-    '* this'
 ```
 ``` bnf
 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
-form “`&` *identifier*” or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
 compatibility with ISO C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
@@ -413,66 +458,62 @@ or `this` shall not appear more than once in a *lambda-capture*.
 ``` cpp
 struct S2 { void f(int i); };
 void S2::f(int i) {
   [&, i]{ };        // OK
   [&, &i]{ };       // error: i preceded by & when & is the default
   [=, *this]{ };    // OK
-  [=, this]{ };     // error: this when = is the default
   [i, i]{ };        // error: i repeated
   [this, *this]{ }; // error: this appears twice
 }
 ```
 — *end example*]
-A *lambda-expression* whose smallest enclosing scope is a block scope (
-[[basic.scope.block]]) is a *local lambda expression*; any other
-*lambda-expression* shall not have a *capture-default* or
-*simple-capture* in its *lambda-introducer*. The *reaching scope* of a
-local lambda expression is the set of enclosing scopes up to and
-including the innermost enclosing function and its parameters.
-[*Note 2*: This reaching scope includes any intervening
-*lambda-expression*s. — *end note*]
 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 an entity. An entity that is designated by a
-*simple-capture* is said to be *explicitly captured*, and shall be
-`*this` (when the *simple-capture* is “`this`” or “`* this`”) or a
-variable with automatic storage duration declared in the reaching scope
-of the local lambda expression.
 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* 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
   performed, and
 - if the capture is by reference, the variable’s lifetime ends when the
   closure object’s lifetime ends.
-[*Note 3*: This enables an *init-capture* like “`x = std::move(x)`”;
 the second “`x`” must bind to a declaration in the surrounding
 context. — *end note*]
 [*Example 3*:
@@ -481,71 +522,100 @@ 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*]
-A *lambda-expression* with an associated *capture-default* that does not
-explicitly capture `*this` or a variable with automatic storage duration
-(this excludes any *id-expression* that has been found to refer to an
-*init-capture*'s associated non-static data member), is said to
-*implicitly capture* the entity (i.e., `*this` or a variable) if the
-*compound-statement*:
-- odr-uses ([[basic.def.odr]]) the entity (in the case of a variable),
-- odr-uses ([[basic.def.odr]]) `this` (in the case of the object
- designated by `*this`), or
-- names the entity in a potentially-evaluated expression (
- [[basic.def.odr]]) where the enclosing full-expression depends on a
- generic lambda parameter declared within the reaching scope of the
-  *lambda-expression*.
 [*Example 4*:
 ``` cpp
-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 g2 = [=](auto a) {
     int selector[sizeof(a) == 1 ? 1 : 2]{};
-    f(x, selector);             // OK: is a dependent expression, so captures x
   };
 }
 ```
 — *end example*]
-All such implicitly captured entities shall be declared within the
-reaching scope of the lambda expression.
-[*Note 4*: The implicit capture of an entity by a nested
-*lambda-expression* can cause its implicit capture by the containing
-*lambda-expression* (see below). Implicit odr-uses of `this` can result
-in implicit capture. — *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*. If
-`*this` is captured by a local lambda expression, its nearest enclosing
-function shall be a non-static member function. If a *lambda-expression*
-or an instantiation of the function call operator template of a generic
-lambda odr-uses ([[basic.def.odr]]) `this` or a variable with automatic
-storage duration from its reaching scope, that entity shall be captured
-by the *lambda-expression*. If a *lambda-expression* captures an entity
-and that entity is not defined or captured in the immediately enclosing
-lambda expression or function, the program is ill-formed.
-[*Example 5*:
 ``` cpp
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
@@ -559,14 +629,15 @@ void f1(int i) {
     int f;
     void work(int n) {
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
-        auto m4 = [&,j] {       // error: j not captured by m3
-          int x = n;            // error: n implicitly captured by m4 but not captured by m3
           x += m;               // OK: m implicitly captured by m4 and explicitly captured by m3
-          x += i;               // error: i is outside of the reaching scope
           x += f;               // OK: this captured implicitly by m4 and explicitly by m3
         };
       };
     }
   };
@@ -576,11 +647,11 @@ struct s2 {
   double ohseven = .007;
   auto f() {
     return [this] {
       return [*this] {
           return ohseven;       // OK
-      }
     }();
   }
   auto g() {
     return [] {
       return [*this] { };       // error: *this not captured by outer lambda-expression
@@ -589,23 +660,30 @@ struct s2 {
 };
 ```
 — *end example*]
-A *lambda-expression* appearing in a default argument shall not
-implicitly or explicitly capture any entity.
-[*Example 6*:
 ``` cpp
 void f2() {
   int i = 1;
-  void g1(int = ([i]{ return i; })());          // ill-formed
-  void g2(int = ([i]{ return 0; })());          // ill-formed
-  void g3(int = ([=]{ return i; })());          // ill-formed
   void g4(int = ([=]{ return 0; })());          // OK
   void g5(int = ([]{ return sizeof i; })());    // OK
 }
 ```
 — *end example*]
@@ -623,36 +701,24 @@ 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 5*: An *id-expression* that is not an odr-use refers to the
-original entity, never to a member of the closure type. Furthermore,
-such an *id-expression* does not cause the implicit capture of the
 entity. — *end note*]
-If `*this` is captured by copy, each odr-use of `this` is transformed
-into a pointer to the corresponding unnamed data member of the closure
-type, cast ([[expr.cast]]) to the type of `this`.
-[*Note 6*: The cast ensures that the transformed expression is a
-prvalue. — *end note*]
-An *id-expression* within the *compound-statement* of a
-*lambda-expression* that is an odr-use of a reference captured by
-reference refers to the entity to which the captured reference is bound
-and not to the captured reference.
-[*Note 7*: The validity of such captures is determined by the lifetime
-of the object to which the reference refers, not by the lifetime of the
-reference itself. — *end note*]
-[*Example 7*:
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
@@ -660,27 +726,21 @@ void g() {
     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
   };
 }
-auto h(int &r) {
-  return [&] {
-    ++r;            // Valid after h returns if the lifetime of the
-                    // object to which r is bound has not ended
-  };
-}
 ```
 — *end example*]
 An entity is *captured by reference* if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional
 unnamed non-static data members are declared in the closure type for
 entities captured by reference. If declared, such non-static data
 members shall be of literal type.
-[*Example 8*:
 ``` cpp
 // The inner closure type must be a literal type regardless of how reference captures are represented.
 static_assert([](int n) { return [&n] { return ++n; }(); }(3) == 4);
 ```
@@ -688,22 +748,44 @@ static_assert([](int n) { return [&n] { return ++n; }(); }(3) == 4);
 — *end example*]
 A bit-field or a member of an anonymous union shall not be captured by
 reference.
 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 9*:
-The nested lambda expressions and invocations below will output
 `123234`.
 ``` cpp
 int a = 1, b = 1, c = 1;
 auto m1 = [a, &b, &c]() mutable {
@@ -719,61 +801,43 @@ m1();
 std::cout << a << b << c;
 ```
 — *end example*]
-Every occurrence of `decltype((x))` where `x` is a possibly
-parenthesized *id-expression* that names an entity of automatic storage
-duration is treated as if `x` were transformed into an access to a
-corresponding data member of the closure type that would have been
-declared if `x` were an odr-use of the denoted entity.
-[*Example 10*:
-``` cpp
-void f3() {
-  float x, &r = x;
-  [=] {                     // x and r are not captured (appearance in a decltype operand is not an odr-use)
-    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& (transformation not considered)
-    decltype((r)) r2 = y2;  // r2 has type float const&
-  };
-}
-```
-— *end example*]
 When the *lambda-expression* is evaluated, the entities that are
 captured by copy are used to direct-initialize each corresponding
 non-static data member of the resulting closure object, and the
 non-static data members corresponding to the *init-capture*s are
 initialized as indicated by the corresponding *initializer* (which may
 be copy- or direct-initialization). (For array members, the array
 elements are direct-initialized in increasing subscript order.) These
 initializations are performed in the (unspecified) order in which the
 non-static data members are declared.
-[*Note 8*: This ensures that the destructions will occur in the reverse
 order of the constructions. — *end note*]
-[*Note 9*: If a non-reference entity is implicitly or explicitly
 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* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]). An *init-capture* followed by an ellipsis is
-ill-formed.
-[*Example 11*:
 ``` cpp
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
   lm();
 }
 ```
 — *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.
 [*Example 1*:
 ``` cpp
 #include <algorithm>
 ```
 — *end example*]
 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`
 auto x3 = []()->auto&& { return j; };   // OK: return type is int&
 ```
 — *end example*]
+A lambda is a *generic lambda* if the *lambda-expression* has any
+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>
 The type of a *lambda-expression* (which is also the type of the closure
 object) is a unique, unnamed non-union class type, called the *closure
 type*, whose properties are described below.
 The closure type is declared in the smallest block scope, class scope,
 or namespace scope that contains the corresponding *lambda-expression*.
 [*Note 1*: This determines the set of namespaces and classes associated
+with the closure type [[basic.lookup.argdep]]. The parameter types of a
+*lambda-declarator* do not affect these associated namespaces and
 classes. — *end note*]
+The closure type is not an aggregate type [[dcl.init.aggr]]. An
 implementation may define the closure type differently from what is
 described below provided this does not alter the observable behavior of
 the program other than by changing:
 - the size and/or alignment of the closure type,
+- whether the closure type is trivially copyable [[class.prop]], or
+- whether the closure type is a standard-layout class [[class.prop]].
 An implementation shall not add members of rvalue reference type to the
 closure type.
+The closure type for a *lambda-expression* has a public inline function
+call operator (for a non-generic lambda) or function call operator
+template (for a generic lambda) [[over.call]] whose parameters and
 return type are described by the *lambda-expression*’s
+*parameter-declaration-clause* and *trailing-return-type* respectively,
+and whose *template-parameter-list* consists of the specified
+*template-parameter-list*, if any. The *requires-clause* of the function
+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; };
 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
 struct NonLiteral {
   NonLiteral(int n) : n(n) { }
   int n;
 };
+static_assert(ID(NonLiteral{3}).n == 3); // error
 ```
 — *end example*]
 [*Example 3*:
 // Since two below is not declared constexpr, an evaluation of its constexpr member function call operator
 // cannot perform an lvalue-to-rvalue conversion on one of its subobjects (that represents its capture)
 // in a constant expression.
 auto two = monoid(2);
 assert(two() == 2); // OK, not a constant expression.
+static_assert(add(one)(one)() == two()); // error: two() is not a constant expression
 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 = ...;
+auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
+         (T1 a1, T1 b1, T2 a2, auto a3, auto a4) requires C3<decltype(a4), T2> {
+  // T2 is constrained by a type-constraint.
+  // T1 and T2 are constrained by a requires-clause, and
+  // T2 and the type of a4 are constrained by a trailing requires-clause.
+};
+```
+— *end example*]
+— *end note*]
 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
 };
 ```
 — *end note*]
+[*Example 5*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 — *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; };
 static_assert(Fwd(C,3) == 3);   // OK
 // No specialization of the function call operator template can be constexpr (due to the local static).
 auto NC = [](auto a) { static int s; return a; };
+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);
 Further, a variable `__func__` is implicitly defined at the beginning of
 the *compound-statement* of the *lambda-expression*, with semantics as
 described in  [[dcl.fct.def.general]].
 The closure type associated with a *lambda-expression* has no default
+constructor if the *lambda-expression* has a *lambda-capture* and a
+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
+[[temp.explicit]], explicitly specialized [[temp.expl.spec]], or named
+in a friend declaration [[class.friend]].
 #### Captures <a id="expr.prim.lambda.capture">[[expr.prim.lambda.capture]]</a>
 ``` bnf
 lambda-capture:
     '='
 ```
 ``` bnf
 capture-list:
+    capture
+    capture-list ',' capture
 ```
 ``` bnf
 capture:
     simple-capture
     init-capture
 ```
 ``` bnf
 simple-capture:
+    identifier '...'ₒₚₜ
+    '&' identifier '...'ₒₚₜ
+    this
+    '*' 'this'
 ```
 ``` bnf
 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
+form “`&` *identifier* `...`ₒₚₜ ”, “`this`”, or “`* this`”.
 [*Note 1*: The form `[&,this]` is redundant but accepted for
 compatibility with ISO C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 ``` cpp
 struct S2 { void f(int i); };
 void S2::f(int i) {
   [&, i]{ };        // OK
+  [&, this, i]{ };  // OK, equivalent to [&, i]
   [&, &i]{ };       // error: i preceded by & when & is the default
   [=, *this]{ };    // OK
+  [=, this]{ };     // OK, equivalent to [=]
   [i, i]{ };        // error: i repeated
   [this, *this]{ }; // error: this appears twice
 }
 ```
 — *end example*]
+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
   performed, and
 - if the capture is by reference, the variable’s lifetime ends when the
   closure object’s lifetime ends.
+[*Note 2*: This enables an *init-capture* like “`x = std::move(x)`”;
 the second “`x`” must bind to a declaration in the surrounding
 context. — *end note*]
 [*Example 3*:
 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
+local entities as follows:
+- An *id-expression* that names a local entity potentially references
+  that entity; an *id-expression* that names one or more non-static
+ class members and does not form a pointer to member [[expr.unary.op]]
+  potentially references `*this`. \[*Note 3*: This occurs even if
+ overload resolution selects a static member function for the
+ *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]].
 [*Example 4*:
 ``` cpp
+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>
+void f(int n) {
+  [=](auto a) {
+    if constexpr (B && sizeof(a) > 4) {
+      (void)n;                  // captures n regardless of the value of B and sizeof(int)
+    }
+  }(0);
+}
+```
+— *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*]
+[*Example 6*:
 ``` cpp
 void f1(int i) {
   int const N = 20;
   auto m1 = [=]{
     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
         };
       };
     }
   };
   double ohseven = .007;
   auto f() {
     return [this] {
       return [*this] {
           return ohseven;       // OK
+      };
     }();
   }
   auto g() {
     return [] {
       return [*this] { };       // error: *this not captured by outer lambda-expression
 };
 ```
 — *end example*]
+[*Note 6*: Because local entities are not odr-usable within a default
+argument [[basic.def.odr]], a *lambda-expression* appearing in a default
+argument cannot implicitly or explicitly capture any local entity. Such
+a *lambda-expression* can still have an *init-capture* if any
+full-expression in its *initializer* satisfies the constraints of an
+expression appearing in a default argument
+[[dcl.fct.default]]. — *end note*]
+[*Example 7*:
 ``` cpp
 void f2() {
   int i = 1;
+  void g1(int = ([i]{ return i; })());          // error
+  void g2(int = ([i]{ return 0; })());          // error
+  void g3(int = ([=]{ return i; })());          // error
   void g4(int = ([=]{ return 0; })());          // OK
   void g5(int = ([]{ return sizeof i; })());    // OK
+  void g6(int = ([x=1]{ return x; })());        // OK
+  void g7(int = ([x=i]{ return x; })());        // error
 }
 ```
 — *end example*]
 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
+*id-expression* can still cause the implicit capture of the
 entity. — *end note*]
+If `*this` is captured by copy, each expression that odr-uses `*this` is
+transformed to instead refer to the corresponding unnamed data member of
+the closure type.
+[*Example 8*:
 ``` 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
   };
 }
 ```
 — *end example*]
 An entity is *captured by reference* if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional
 unnamed non-static data members are declared in the closure type for
 entities captured by reference. If declared, such non-static data
 members shall be of literal type.
+[*Example 9*:
 ``` cpp
 // The inner closure type must be a literal type regardless of how reference captures are represented.
 static_assert([](int n) { return [&n] { return ++n; }(); }(3) == 4);
 ```
 — *end example*]
 A bit-field or a member of an anonymous union shall not be captured by
 reference.
+An *id-expression* within the *compound-statement* of a
+*lambda-expression* that is an odr-use of a reference captured by
+reference refers to the entity to which the captured reference is bound
+and not to the captured reference.
+[*Note 8*: The validity of such captures is determined by the lifetime
+of the object to which the reference refers, not by the lifetime of the
+reference itself. — *end note*]
+[*Example 10*:
+``` cpp
+auto h(int &r) {
+  return [&] {
+    ++r;            // Valid after h returns if the lifetime of the
+                    // object to which r is bound has not ended
+  };
+}
+```
+— *end example*]
 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
 `123234`.
 ``` cpp
 int a = 1, b = 1, c = 1;
 auto m1 = [a, &b, &c]() mutable {
 std::cout << a << b << c;
 ```
 — *end example*]
 When the *lambda-expression* is evaluated, the entities that are
 captured by copy are used to direct-initialize each corresponding
 non-static data member of the resulting closure object, and the
 non-static data members corresponding to the *init-capture*s are
 initialized as indicated by the corresponding *initializer* (which may
 be copy- or direct-initialization). (For array members, the array
 elements are direct-initialized in increasing subscript order.) These
 initializations are performed in the (unspecified) order in which the
 non-static data members are declared.
+[*Note 9*: This ensures that the destructions will occur in the reverse
 order of the constructions. — *end note*]
+[*Note 10*: If a non-reference entity is implicitly or explicitly
 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>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
   lm();
+  auto lm2 = [...xs=std::move(args)] { return g(xs...); };
+  lm2();
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa