[expr.prim] - C++14 → C++17

Files changed (1) hide show

tmp/tmp8vm58ccx/{from.md → to.md} +606 -272

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

@@ -1,77 +1,75 @@
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
-### General <a id="expr.prim.general">[[expr.prim.general]]</a>
 ``` bnf
 primary-expression:
     literal
     'this'
     '(' expression ')'
     id-expression
     lambda-expression
 ```
-``` bnf
-id-expression:
-    unqualified-id
-    qualified-id
-```
-``` bnf
-unqualified-id:
-    identifier
-    operator-function-id
-    conversion-function-id
-    literal-operator-id
-    '~' class-name
-    '~' decltype-specifier
-    template-id
-```
 A *literal* is a primary expression. Its type depends on its form (
 [[lex.literal]]). A string literal is an lvalue; all other literals are
 prvalues.
 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-qualifer-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). this is because
-declaration matching does not occur until the complete declarator is
-known. Unlike the object expression in other contexts, `*this` is not
-required to be of complete type for purposes of class member access (
-[[expr.ref]]) outside the member function body. only class members
-declared prior to the declaration are visible.
 ``` cpp
 struct A {
   char g();
   template<class T> auto f(T t) -> decltype(t + g())
     { return t + g(); }
 };
 template auto A::f(int t) -> decltype(t + g());
 ```
 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 *brace-or-equal-initializer*.
-It shall not appear elsewhere in the *member-declarator*.
 The expression `this` shall not appear in any other context.
 ``` cpp
 class Outer {
   int a[sizeof(*this)];               // error: not inside a member function
-  unsigned int sz = sizeof(*this);    // OK: in brace-or-equal-initializer
   void f() {
     int b[sizeof(*this)];             // OK
     struct Inner {
@@ -79,32 +77,85 @@ class Outer {
     };
   }
 };
 ```
-A parenthesized expression is a primary expression whose type and value
-are identical to those of the enclosed expression. The presence of
-parentheses does not affect whether the expression is an lvalue. The
 parenthesized expression can be used in exactly the same contexts as
-those where the enclosed expression can be used, and with the same
-meaning, except as otherwise indicated.
-An *id-expression* is a restricted form of a *primary-expression*. an
-*id-expression* can appear after `.` and `->` operators ([[expr.ref]]).
 An *identifier* is an *id-expression* provided it has been suitably
-declared (Clause  [[dcl.dcl]]). for *operator-function-id*s, see
-[[over.oper]]; for *conversion-function-id*s, see  [[class.conv.fct]];
-for *literal-operator-id*s, see  [[over.literal]]; for *template-id*s,
-see  [[temp.names]]. A *class-name* or *decltype-specifier* prefixed by
-`~` denotes a destructor; see  [[class.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]]). The type of the expression is the type of
-the *identifier*. The result is the entity denoted by the identifier.
-The result is an lvalue if the entity is a function, variable, or data
-member and a prvalue otherwise.
 ``` bnf
 qualified-id:
     nested-name-specifier 'template'ₒₚₜ unqualified-id
 ```
@@ -125,29 +176,36 @@ 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 (Clause  [[class.derived]]), is a *qualified-id*;
 [[class.qual]] describes name lookup for class members that appear in
-*qualified-ids*. 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. a class member
-can be referred to using a *qualified-id* at any point in its potential
-scope ([[basic.scope.class]]). Where *class-name* `::~` *class-name* is
-used, the two *class-name*s shall refer to the same class; this notation
-names the destructor ([[class.dtor]]). The form
-`~` *decltype-specifier* also denotes the destructor, but it shall not
-be used as the *unqualified-id* in a *qualified-id*. a *typedef-name*
-that names a class is a *class-name* ([[class.name]]).
-A `::`, or a *nested-name-specifier* that names a namespace (
-[[basic.namespace]]), in either case 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-ids*. 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 or a variable 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
@@ -156,141 +214,104 @@ result is a prvalue.
 In a *qualified-id*, if the *unqualified-id* is a
 *conversion-function-id*, its *conversion-type-id* shall denote the same
 type in both the context in which the entire *qualified-id* occurs and
 in the context of the class denoted by the *nested-name-specifier*.
-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[^4] 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.
-  ``` cpp
-  struct S {
-    int m;
-  };
-  int i = sizeof(S::m);           // OK
-  int j = sizeof(S::m + 42);      // OK
-  ```
 ### Lambda expressions <a id="expr.prim.lambda">[[expr.prim.lambda]]</a>
-Lambda expressions provide a concise way to create simple function
-objects.
-``` cpp
-#include <algorithm>
-#include <cmath>
-void abssort(float* x, unsigned N) {
-  std::sort(x, x + N,
-    [](float a, float b) {
-      return std::abs(a) < std::abs(b);
-    });
-}
-```
 ``` bnf
 lambda-expression:
     lambda-introducer lambda-declaratorₒₚₜ compound-statement
 ```
 ``` bnf
 lambda-introducer:
     '[' lambda-captureₒₚₜ ']'
 ```
-``` bnf
-lambda-capture:
-    capture-default
-    capture-list
-    capture-default ',' capture-list
-```
-``` bnf
-capture-default:
-    '&'
-    '='
-```
-``` bnf
-capture-list:
-    capture '...'ₒₚₜ
-    capture-list ',' capture '...'ₒₚₜ
-```
-``` bnf
-capture:
-    simple-capture
-    init-capture
-```
-``` bnf
-simple-capture:
-    identifier
-    '&' identifier
-    'this'
-```
-``` bnf
-init-capture:
-    identifier initializer
-    '&' identifier initializer
-```
 ``` bnf
 lambda-declarator:
-    '(' parameter-declaration-clause ')' 'mutable'ₒₚₜ
- exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
 ```
-The evaluation of a *lambda-expression* results in a prvalue temporary (
-[[class.temporary]]). This temporary 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. The intention
-is to prevent lambdas from appearing in a signature. A closure object
-behaves like a function object ([[function.objects]]).
-The type of the *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. This class type
-is neither an aggregate ([[dcl.init.aggr]]) nor a literal type (
-[[basic.types]]). The closure type is declared in the smallest block
-scope, class scope, or namespace scope that contains the corresponding
-*lambda-expression*. 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. 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.
-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 *trailing-return-type* if provided
-and/or deduced from `return` statements as described in
-[[dcl.spec.auto]].
-``` 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&
-```
 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
@@ -304,13 +325,16 @@ 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*.
 ``` 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 [=]() {
@@ -322,42 +346,99 @@ auto glambda = [](auto a, auto&& b) { return a < b; };
                    { std::cout << v1 << v2 << v3; } );
 auto q = p(1, 'a', 3.14);                              // OK: outputs 1a3.14
 q();                                                   // OK: outputs 1a3.14
 ```
-This 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 *exception-specification*
 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. Names referenced in the
-*lambda-declarator* are looked up in the context in which the
-*lambda-expression* appears.
 The closure type for a non-generic *lambda-expression* with no
-*lambda-capture* has a public non-virtual non-explicit const 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 value returned by this conversion function
-shall be the address of a function that, when invoked, has the same
-effect as invoking the closure type’s function call operator. For a
-generic lambda with no *lambda-capture*, the closure type has a public
-non-virtual non-explicit const 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. 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 instantiation of the function call operator
-template with the same template arguments as those deduced for the
-conversion function template. Consider the following:
 ``` cpp
 auto glambda = [](auto a) { return a; };
 int (*fp)(int) = glambda;
 ```
@@ -379,10 +460,14 @@ struct Closure {
   template<class T> operator fptr_t<T>() const
     { return &lambda_call_operator_invoker; }
 };
 ```
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 void g(int (*)(int))    { }  // #1
@@ -397,33 +482,63 @@ 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
 ```
 The value returned by any given specialization of this conversion
-function template shall be the address of a function that, when invoked,
 has the same effect as invoking the generic lambda’s corresponding
-function call operator template specialization. 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.
 ``` 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 *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*.
 ``` cpp
 struct S1 {
   int x, y;
   int operator()(int);
   void f() {
@@ -433,46 +548,135 @@ 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]].
 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*”. Ignoring appearances in *initializer*s of
-*init-capture*s, an identifier 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]{ };     // error: this when = is the default
   [i, i]{ };        // error: i repeated
 }
 ```
 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. This
-reaching scope includes any intervening *lambda-expression*s.
 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` or a variable with automatic storage duration declared in the
-reaching scope of the local lambda expression.
 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:
@@ -482,34 +686,45 @@ region is the *lambda-expression*’s *compound-statement*, except that:
   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.
-This enables an *init-capture* like “`x = std::move(x)`”; the second
-“`x`” must bind to a declaration in the surrounding context.
 ``` cpp
 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.
 ```
 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, 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*.
 ``` cpp
 void f(int, const int (&)[2] = {})    { }   // #1
 void f(const int&, const int (&)[1])  { }   // #2
 void test() {
   const int x = 17;
@@ -522,63 +737,85 @@ void test() {
     f(x, selector);             // OK: is a dependent expression, so captures x
   };
 }
 ```
 All such implicitly captured entities shall be declared within the
-reaching scope of the lambda expression. 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.
 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.
 ``` cpp
 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 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
         };
       };
     }
   };
 }
 ```
 A *lambda-expression* appearing in a default argument shall not
 implicitly or explicitly capture any entity.
 ``` cpp
 void f2() {
   int i = 1;
   void g1(int = ([i]{ return i; })());          // ill-formed
   void g2(int = ([i]{ return 0; })());          // ill-formed
@@ -586,38 +823,105 @@ void f2() {
   void g4(int = ([=]{ return 0; })());          // OK
   void g5(int = ([]{ return sizeof i; })());    // OK
 }
 ```
-An entity is *captured by copy* if it is implicitly captured and the
-*capture-default* is `=` or if it is explicitly captured with a capture
-that is not of the form `&` *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 type
-of the corresponding captured entity if the entity is not a reference to
-an object, or the referenced type otherwise. If the captured entity is a
-reference to a function, the corresponding data member is also a
-reference to a function. A member of an anonymous union shall not be
-captured by copy.
 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. 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`.
-the nested lambda expressions and invocations below will output
 `123234`.
 ``` cpp
 int a = 1, b = 1, c = 1;
 auto m1 = [a, &b, &c]() mutable {
@@ -631,86 +935,116 @@ auto m1 = [a, &b, &c]() mutable {
 a = 2; b = 2; c = 2;
 m1();
 std::cout << a << b << c;
 ```
-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. 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. If `this` is captured, each odr-use of
-`this` is transformed into an access to the corresponding unnamed data
-member of the closure type, cast ([[expr.cast]]) to the type of `this`.
-The cast ensures that the transformed expression is a prvalue.
-``` 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
-  };
-}
-```
 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.
 ``` 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&
   };
 }
 ```
-The closure type associated with a *lambda-expression* has a deleted (
-[[dcl.fct.def.delete]]) default constructor and a deleted copy
-assignment operator. It has an implicitly-declared copy constructor (
-[[class.copy]]) and may have an implicitly-declared move constructor (
-[[class.copy]]). The copy/move constructor is implicitly defined in the
-same way as any other implicitly declared copy/move constructor would be
-implicitly defined.
-The closure type associated with a *lambda-expression* has an
-implicitly-declared destructor ([[class.dtor]]).
 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. This ensures that the destructions
-will occur in the reverse order of the constructions.
-If an 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.
 A *simple-capture* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]). An *init-capture* followed by an ellipsis is
 ill-formed.
 ``` cpp
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
   lm();
 }
 ```

 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
 ``` bnf
 primary-expression:
     literal
     'this'
     '(' expression ')'
     id-expression
     lambda-expression
+    fold-expression
 ```
+### Literals <a id="expr.prim.literal">[[expr.prim.literal]]</a>
 A *literal* is a primary expression. Its type depends on its form (
 [[lex.literal]]). A string literal is an lvalue; all other literals are
 prvalues.
+### 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*]
+Unlike the object expression in other contexts, `*this` is not required
+to be of complete type for purposes of class member access (
+[[expr.ref]]) outside the member function body.
+[*Note 2*: Only class members declared prior to the declaration are
+visible. — *end note*]
+[*Example 1*:
 ``` cpp
 struct A {
   char g();
   template<class T> auto f(T t) -> decltype(t + g())
     { return t + g(); }
 };
 template auto A::f(int t) -> decltype(t + g());
 ```
+— *end example*]
 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 {
     };
   }
 };
 ```
+— *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
+```
+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[^4] 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*]
+#### Unqualified names <a id="expr.prim.id.unqual">[[expr.prim.id.unqual]]</a>
+``` bnf
+unqualified-id:
+    identifier
+    operator-function-id
+    conversion-function-id
+    literal-operator-id
+    '~' class-name
+    '~' decltype-specifier
+    template-id
+```
 An *identifier* is an *id-expression* provided it has been suitably
+declared (Clause  [[dcl.dcl]]).
+[*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
+*conversion-function-id*s, see  [[class.conv.fct]]; for
+*literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
+[[temp.names]]. A *class-name* or *decltype-specifier* prefixed by `~`
+denotes a destructor; see  [[class.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 type of the expression is the type of the *identifier*. The result
+is the entity denoted by the identifier. The expression is an lvalue if
+the entity is a function, variable, or data member and a prvalue
+otherwise; it is a bit-field if the identifier designates a bit-field (
+[[dcl.struct.bind]]).
+#### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier 'template'ₒₚₜ unqualified-id
 ```
 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 (Clause  [[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 *class-name* `::~` *class-name* is used, the two *class-name*s
+shall refer to the same class; this notation names the destructor (
+[[class.dtor]]). The form `~` *decltype-specifier* also denotes the
+destructor, but it shall not be used as the *unqualified-id* in a
+*qualified-id*.
+[*Note 2*: A *typedef-name* that names a class is a *class-name* (
+[[class.name]]). — *end note*]
+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 or a variable 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
 In a *qualified-id*, if the *unqualified-id* is a
 *conversion-function-id*, its *conversion-type-id* shall denote the same
 type in both the context in which the entire *qualified-id* occurs and
 in the context of the class denoted by the *nested-name-specifier*.
 ### 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>
+#include <cmath>
+void abssort(float* x, unsigned N) {
+  std::sort(x, x + N, [](float a, float b) { return std::abs(a) < std::abs(b); });
+}
+```
+— *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`
+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*]
+#### 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
 *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; };
 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 [=]() {
                    { 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 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
+auto ID = [](auto a) { return a; };
+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*:
+``` cpp
+auto monoid = [](auto v) { return [=] { return v; }; };
+auto add = [](auto m1) constexpr {
+  auto ret = m1();
+  return [=](auto m2) mutable {
+    auto m1val = m1();
+    auto plus = [=](auto m2val) mutable constexpr
+                   { return m1val += m2val; };
+    ret = plus(m2());
+    return monoid(ret);
+  };
+};
+constexpr auto zero = monoid(0);
+constexpr auto one = monoid(1);
+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
+instantiation of the function call operator template with the same
+template arguments as those deduced for the conversion function
+template. Consider the following:
 ``` cpp
 auto glambda = [](auto a) { return a; };
 int (*fp)(int) = glambda;
 ```
   template<class T> operator fptr_t<T>() const
     { return &lambda_call_operator_invoker; }
 };
 ```
+— *end note*]
+[*Example 4*:
 ``` cpp
 void f1(int (*)(int))   { }
 void f2(char (*)(int))  { }
 void g(int (*)(int))    { }  // #1
 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. `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)
 ```
+— *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);
   void f() {
     };
   }
 };
 ```
+— *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 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:
+    capture-default
+    capture-list
+    capture-default ',' capture-list
+```
+``` bnf
+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
+or `this` shall not appear more than once in a *lambda-capture*.
+[*Example 1*:
 ``` 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:
   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*:
 ``` cpp
 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;
     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 = [=]{
     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 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
         };
       };
     }
   };
 }
+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
+    }();
+  }
+};
 ```
+— *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 g4(int = ([=]{ return 0; })());          // OK
   void g5(int = ([]{ return sizeof i; })());    // OK
 }
 ```
+— *end example*]
+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
+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;
+  [=] {
+    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);
+```
+— *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 {
 a = 2; b = 2; c = 2;
 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*]
+### Fold expressions <a id="expr.prim.fold">[[expr.prim.fold]]</a>
+A fold expression performs a fold of a template parameter pack (
+[[temp.variadic]]) over a binary operator.
+``` bnf
+fold-expression:
+    '(' cast-expression fold-operator '...' ')'
+    '(' '...' fold-operator cast-expression ')'
+    '(' cast-expression fold-operator '...' fold-operator cast-expression ')'
+```
+``` bnf
+%% Ed. note: character protrusion would misalign operators with leading `-`.
+fold-operator: one of
+    '+ ' '- ' '* ' '/ ' '% ' '^ ' '& ' '| ' '<< ' '>> '
+    '+=' '-=' '*=' '/=' '%=' '^=' '&=' '|=' '<<=' '>>=' '='
+    '==' '!=' '< ' '> ' '<=' '>=' '&&' '||' ', ' '.* ' '->*'
+```
+An expression of the form `(...` *op* `e)` where *op* is a
+*fold-operator* is called a *unary left fold*. An expression of the form
+`(e` *op* `...)` where *op* is a *fold-operator* is called a *unary
+right fold*. Unary left folds and unary right folds are collectively
+called *unary folds*. In a unary fold, the *cast-expression* shall
+contain an unexpanded parameter pack ([[temp.variadic]]).
+An expression of the form `(e1` *op1* `...` *op2* `e2)` where *op1* and
+*op2* are *fold-operator*s is called a *binary fold*. In a binary fold,
+*op1* and *op2* shall be the same *fold-operator*, and either `e1` shall
+contain an unexpanded parameter pack or `e2` shall contain an unexpanded
+parameter pack, but not both. If `e2` contains an unexpanded parameter
+pack, the expression is called a *binary left fold*. If `e1` contains an
+unexpanded parameter pack, the expression is called a *binary right
+fold*.
+[*Example 1*:
+``` cpp
+template<typename ...Args>
+bool f(Args ...args) {
+  return (true && ... && args); // OK
+}
+template<typename ...Args>
+bool f(Args ...args) {
+  return (args + ... + args);   // error: both operands contain unexpanded parameter packs
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa