[expr.prim.lambda] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp967eflqv/{from.md → to.md} +155 -79

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

@@ -15,14 +15,15 @@ lambda-introducer:
 ```
 ``` 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
@@ -31,12 +32,11 @@ lambda-specifier:
     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.
@@ -62,12 +62,24 @@ 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
@@ -77,19 +89,20 @@ 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;
@@ -100,53 +113,62 @@ auto x3 = [&]()->auto&& { return j; };  // OK, return type is int&
 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 can
@@ -183,11 +205,12 @@ std::cout << fact(5);                                           // OK, outputs 1
 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
@@ -211,13 +234,14 @@ function or static member function template [[class.static.mfct]] if the
 `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
@@ -296,35 +320,80 @@ auto f = []<typename T1, C1 T2> requires C2<sizeof(T1) + sizeof(T2)>
 — *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. 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
@@ -356,11 +425,11 @@ struct Closure {
 };
 ```
 — *end note*]
-[*Example 6*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
@@ -380,27 +449,26 @@ 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)
@@ -410,11 +478,11 @@ GL_int(3);                      // OK, same as GL(3)
 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; };
@@ -429,11 +497,11 @@ static_assert(Fwd(NC,3) == 3);  // error
 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);
@@ -446,23 +514,25 @@ struct S1 {
 };
 ```
 — *end example*]
-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 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]].
@@ -500,30 +570,30 @@ capture:
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
-    '*' 'this'
 ```
 ``` bnf
 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
 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
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
@@ -542,14 +612,19 @@ void S2::f(int i) {
 ```
 — *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* 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*.
@@ -767,11 +842,12 @@ void f2() {
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
-  `this`, `&` *identifier*, or `&` *identifier* *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
@@ -798,11 +874,11 @@ 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
   };
 }
 ```

 ```
 ``` bnf
 lambda-declarator:
     lambda-specifier-seq noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
+       function-contract-specifier-seqₒₚₜ
+ noexcept-specifier attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
+    trailing-return-typeₒₚₜ function-contract-specifier-seqₒₚₜ
     '(' parameter-declaration-clause ')' lambda-specifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+       trailing-return-typeₒₚₜ requires-clauseₒₚₜ function-contract-specifier-seqₒₚₜ
 ```
 ``` bnf
 lambda-specifier:
     consteval
     static
 ```
 ``` bnf
 lambda-specifier-seq:
+    lambda-specifier lambda-specifier-seqₒₚₜ
 ```
 A *lambda-expression* provides a concise way to create a simple function
 object.
 *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`.
+[*Example 2*:
+``` cpp
+auto x = []<class T> requires T::operator int [[some_attribute]] (int) { }
+```
+— *end example*]
+— *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-capture*.
 [*Note 3*: The trailing *requires-clause* is described in
 [[dcl.decl]]. — *end note*]
+A *lambda-expression*'s *parameter-declaration-clause* is the
+*parameter-declaration-clause* of the *lambda-expression*'s
+*lambda-declarator*, if any, or empty otherwise. 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 3*:
 ``` 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;
 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 4*:
 ``` cpp
+auto x = [](int i, auto a) { return i; }; // OK, a generic lambda
+auto y = [](this auto self, int i) { return i; }; // OK, a generic lambda
+auto z = []<class T>(int i) { return i; };              // 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 incomplete until the end of its corresponding
+*compound-statement*.
 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]]; it is a
+structural type [[term.structural.type]] if and only if the lambda has
+no *lambda-capture*. 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]],
+- whether the closure type is trivially relocatable [[class.prop]],
+- whether the closure type is replaceable [[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 those of 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 function call operator or the
+function call operator template are direct members of the closure type.
+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 can
 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 publicly and unambiguously derived from the closure type,
+  or
 - a reference to a possibly cv-qualified such type.
 [*Example 2*:
 ``` cpp
 `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* or
+*function-contract-specifier* [[dcl.contract.func]] 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
 — *end example*]
 — *end note*]
+If all potential references to a local entity implicitly captured by a
+*lambda-expression* L occur within the function contract assertions
+[[dcl.contract.func]] of the call operator or operator template of L or
+within *assertion-statement*s [[stmt.contract.assert]] within the body
+of L, the program is ill-formed.
+[*Note 4*: Adding a contract assertion to an existing C++ program
+cannot cause additional captures. — *end note*]
+[*Example 6*:
+``` cpp
+static int i = 0;
+void test() {
+  auto f1 = [=] pre(i > 0) {};  // OK, no local entities are captured.
+  int i = 1;
+  auto f2 = [=] pre(i > 0) {};  // error: cannot implicitly capture i here
+  auto f3 = [i] pre(i > 0) {};  // OK, i is captured explicitly.
+  auto f4 = [=] {
+    contract_assert(i > 0);     // error: cannot implicitly capture i here
+  };
+  auto f5 = [=] {
+    contract_assert(i > 0);     // OK, i is referenced elsewhere.
+    (void)i;
+  };
+  auto f6 = [=] pre(                // #1
+    []{
+      bool x = true;
+      return [=]{ return x; }();    // OK, #1 captures nothing.
+    }()) {};
+  bool y = true;
+  auto f7 = [=] pre([=]{ return y; }());    // error: outer capture of y is invalid.
+}
+```
+— *end example*]
 The closure type for a non-generic *lambda-expression* with no
+*lambda-capture* and no explicit object parameter [[dcl.fct]] 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 a pointer to the function call
+operator. Otherwise, the value returned by this conversion function is a
+pointer to 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* and no explicit object
+parameter [[dcl.fct]], 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 7*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 — *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 a pointer to the corresponding function
+call operator template specialization. Otherwise, the value returned by
+any given specialization of this conversion function template is a
+pointer to 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 need to match the return type and parameter types of the
+pointer to function. — *end note*]
+[*Example 8*:
 ``` 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)
 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 9*:
 ``` cpp
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
 auto C = [](auto a) { return a; };
 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 10*:
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
 };
 ```
 — *end example*]
+Unless the *compound-statement* is that of a
+*consteval-block-declaration* [[dcl.pre]], 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, 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]].
 ``` bnf
 simple-capture:
     identifier '...'ₒₚₜ
     '&' identifier '...'ₒₚₜ
     this
+    '*' this
 ```
 ``` bnf
 init-capture:
     '...'ₒₚₜ identifier initializer
     '&' '...'ₒₚₜ identifier initializer
 ```
 The body of a *lambda-expression* may refer to local entities of
+enclosing 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 C++14. — *end note*]
 Ignoring appearances in *initializer*s of *init-capture*s, an identifier
 or `this` shall not appear more than once in a *lambda-capture*.
 [*Example 1*:
 ```
 — *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]],
+- it appears within a default member initializer and its innermost
+  enclosing scope is the corresponding class scope
+  [[basic.scope.class]], or
+- it appears within a contract assertion and its innermost enclosing
+  scope is the corresponding contract-assertion scope
+  [[basic.scope.contract]].
 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*.
 An entity is *captured by copy* if
 - it is implicitly captured, the *capture-default* is `=`, and the
   captured entity is not `*this`, or
 - it is explicitly captured with a capture that is not of the form
+  `this`, `&` *identifier* `...`ₒₚₜ , or `&` `...`ₒₚₜ  *identifier*
+  *initializer*.
 For each entity captured by copy, an unnamed non-static data member is
 declared in the closure type. The declaration order of these members is
 unspecified. The type of such a data member is the referenced type if
 the entity is a reference to an object, an lvalue reference to the
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
+    int arr[N];     // OK, not an odr-use, refers to variable with automatic storage duration
     f(&N);          // OK, causes N to be captured; &N points to
                     // the corresponding member of the closure type
   };
 }
 ```

Diff to HTML by rtfpessoa