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

Files changed (1) hide show

tmp/tmp8n0nkpz9/{from.md → to.md} +288 -0

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

	@@ -0,0 +1,288 @@

+#### Closure types <a id="expr.prim.lambda.closure">[[expr.prim.lambda.closure]]</a>
+The type of a *lambda-expression* (which is also the type of the closure
+object) is a unique, unnamed non-union class type, called the *closure
+type*, whose properties are described below.
+The closure type is declared in the smallest block scope, class scope,
+or namespace scope that contains the corresponding *lambda-expression*.
+[*Note 1*: This determines the set of namespaces and classes associated
+with the closure type ([[basic.lookup.argdep]]). The parameter types of
+a *lambda-declarator* do not affect these associated namespaces and
+classes. — *end note*]
+The closure type is not an aggregate type ([[dcl.init.aggr]]). An
+implementation may define the closure type differently from what is
+described below provided this does not alter the observable behavior of
+the program other than by changing:
+- the size and/or alignment of the closure type,
+- whether the closure type is trivially copyable (Clause  [[class]]),
+- whether the closure type is a standard-layout class (Clause
+  [[class]]), or
+- whether the closure type is a POD class (Clause  [[class]]).
+An implementation shall not add members of rvalue reference type to the
+closure type.
+The closure type for a non-generic *lambda-expression* has a public
+inline function call operator ([[over.call]]) whose parameters and
+return type are described by the *lambda-expression*’s
+*parameter-declaration-clause* and *trailing-return-type* respectively.
+For a generic lambda, the closure type has a public inline function call
+operator member template ([[temp.mem]]) whose *template-parameter-list*
+consists of one invented type *template-parameter* for each occurrence
+of `auto` in the lambda’s *parameter-declaration-clause*, in order of
+appearance. The invented type *template-parameter* is a parameter pack
+if the corresponding *parameter-declaration* declares a function
+parameter pack ([[dcl.fct]]). The return type and function parameters
+of the function call operator template are derived from the
+*lambda-expression*'s *trailing-return-type* and
+*parameter-declaration-clause* by replacing each occurrence of `auto` in
+the *decl-specifier*s of the *parameter-declaration-clause* with the
+name of the corresponding invented *template-parameter*.
+[*Example 1*:
+``` cpp
+auto glambda = [](auto a, auto&& b) { return a < b; };
+bool b = glambda(3, 3.14);                             // OK
+auto vglambda = [](auto printer) {
+  return [=](auto&& ... ts) {                          // OK: ts is a function parameter pack
+    printer(std::forward<decltype(ts)>(ts)...);
+    return [=]() {
+      printer(ts ...);
+    };
+  };
+};
+auto p = vglambda( [](auto v1, auto v2, auto v3)
+                   { std::cout << v1 << v2 << v3; } );
+auto q = p(1, 'a', 3.14);                              // OK: outputs 1a3.14
+q();                                                   // OK: outputs 1a3.14
+```
+— *end example*]
+The function call operator or operator template is declared `const` (
+[[class.mfct.non-static]]) if and only if the *lambda-expression*’s
+*parameter-declaration-clause* is not followed by `mutable`. It is
+neither virtual nor declared `volatile`. Any *noexcept-specifier*
+specified on a *lambda-expression* applies to the corresponding function
+call operator or operator template. An *attribute-specifier-seq* in a
+*lambda-declarator* appertains to the type of the corresponding function
+call operator or operator template. The function call operator or any
+given operator template specialization is a constexpr function if either
+the corresponding *lambda-expression*'s *parameter-declaration-clause*
+is followed by `constexpr`, or 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;
+```
+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; }
+};
+```
+— *end note*]
+[*Example 4*:
+``` 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
+```
+— *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() {
+    [=]()->int {
+      return operator()(this->x + y); // equivalent to S1::operator()(this->x + (*this).y)
+                                      // this has type 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 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]]).

Diff to HTML by rtfpessoa