[expr.prim.lambda] - C++11 → C++14

Files changed (1) hide show

tmp/tmp2kqlkgff/{from.md → to.md} +268 -100

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

@@ -43,39 +43,54 @@ capture-list:
     capture-list ',' capture '...'ₒₚₜ
 ```
 ``` bnf
 capture:
     identifier
     '&' identifier
     'this'
 ```
 ``` 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]]). 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 not an aggregate ([[dcl.init.aggr]]). 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
@@ -83,52 +98,145 @@ other than by changing:
 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 `()`. If a *lambda-expression* does
-not include a *trailing-return-type*, it is as if the
-*trailing-return-type* denotes the following type:
-- if the *compound-statement* is of the form
-  ``` bnf
-  '{' attribute-specifier-seqₒₚₜ 'return' expression ';' '}'
-  ```
-  the type of the returned expression after lvalue-to-rvalue
-  conversion ([[conv.lval]]), array-to-pointer conversion (
-  [[conv.array]]), and function-to-pointer conversion ([[conv.func]]);
-- otherwise, `void`.
 ``` cpp
 auto x1 = [](int i){ return i; };     // OK: return type is int
-auto x2 = []{ return { 1, 2 }; }; // error: the return type is void (a
-                                  // braced-init-list is not an expression)
 ```
-The closure type for a *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.
-This function call operator 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`. Default arguments (
-[[dcl.fct.default]]) shall not be specified in the
-*parameter-declaration-clause* of a *lambda-declarator*. Any
-*exception-specification* specified on a *lambda-expression* applies to
-the corresponding function call operator. An *attribute-specifier-seq*
-in a *lambda-declarator* appertains to the type of the corresponding
-function call operator. Names referenced in the *lambda-declarator* are
-looked up in the context in which the *lambda-expression* appears.
-The closure type for a *lambda-expression* with no *lambda-capture* has
-a public non-virtual non-explicit const conversion function to pointer
-to function 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.
 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
@@ -148,16 +256,21 @@ struct S1 {
     };
   }
 };
 ```
-If a *lambda-capture* includes a *capture-default* that is `&`, the
-identifiers in the *lambda-capture* shall not be preceded by `&`. If a
-*lambda-capture* includes a *capture-default* that is `=`, the
-*lambda-capture* shall not contain `this` and each identifier it
-contains shall be preceded by `&`. 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
@@ -166,40 +279,89 @@ void S2::f(int i) {
   [i, i]{ };    // error: i repeated
 }
 ```
 A *lambda-expression* whose smallest enclosing scope is a block scope (
-[[basic.scope.local]]) is a *local lambda expression*; any other
-*lambda-expression* shall not have a *capture-list* 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 *identifiers* in a *capture-list* are looked up using the usual
 rules for unqualified name lookup ([[basic.lookup.unqual]]); each such
-lookup shall find a variable with automatic storage duration declared in
-the reaching scope of the local lambda expression. An entity (i.e. a
-variable or `this`) is said to be *explicitly captured* if it appears in
-the *lambda-expression*’s *capture-list*.
-If a *lambda-expression* has an associated *capture-default* and its
-*compound-statement* odr-uses ([[basic.def.odr]]) `this` or a variable
-with automatic storage duration and the odr-used entity is not
-explicitly captured, then the odr-used entity is said to be *implicitly
-captured*; such 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*
-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.
@@ -249,22 +411,25 @@ void f2() {
 }
 ```
 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 does not include an `&`. 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.
 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 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:
@@ -289,30 +454,30 @@ auto m1 = [a, &b, &c]() mutable {
 a = 2; b = 2; c = 2;
 m1();
 std::cout << a << b << c;
 ```
-Every *id-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
@@ -344,24 +509,27 @@ 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. (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 *capture* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]).
 ``` cpp
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };

     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
 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
+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*.
+``` cpp
+auto glambda = [](auto a, auto&& b) { return a < b; };
+  bool b = glambda(3, 3.14);                                  // OK
+  auto vglambda = [](auto printer) {
+     return [=](auto&& ... ts) {                              // OK: ts is a function parameter pack
+         printer(std::forward<decltype(ts)>(ts)...);
+         return [=]() {
+           printer(ts ...);
+         };
+     };
+  };
+  auto p = vglambda( [](auto v1, auto v2, auto v3)
+                         { std::cout << v1 << v2 << v3; } );
+  auto q = p(1, 'a', 3.14);                                   // OK: outputs 1a3.14
+  q();                                                        // OK: outputs 1a3.14
+```
+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;
+```
+The behavior of the conversion function of `glambda` above is like that
+of the following conversion function:
+``` cpp
+struct Closure {
+  template<class T> auto operator()(T t) const { ... }
+  template<class T> static auto lambda_call_operator_invoker(T a) {
+    // forwards execution to operator()(a) and therefore has
+    // the same return type deduced
+    ...
+  }
+  template<class T> using fptr_t =
+     decltype(lambda_call_operator_invoker(declval<T>())) (*)(T);
+  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
+void g(char (*)(char))  { }  // #2
+void h(int (*)(int))    { }  // #3
+void h(char (*)(int))   { }  // #4
+auto glambda = [](auto a) { return a; };
+f1(glambda);  // OK
+f2(glambda);  // error: ID is not convertible
+g(glambda);   // error: ambiguous
+h(glambda);   // OK: calls #3 since it is convertible from ID
+int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK
+```
+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
     };
   }
 };
 ```
+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, 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:
+- 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.
+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;
+  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
+  };
+}
+```
+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.
 }
 ```
 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:
 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
 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...); };

Diff to HTML by rtfpessoa