[expr.prim.lambda] Split specification of lambda expressions into subsections.

Fixes #1155.

Author: jensmaurer

source/expressions.tex

@@ -706,14 +706,35 @@
 The type of the \grammarterm{lambda-expression} (which is also the type of the
 closure object) is a unique, unnamed non-union class type
 --- called the \defn{closure type} ---
-whose properties are described below.
-This class type is not an aggregate type~(\ref{dcl.init.aggr}).
+whose properties are described in section~\ref{expr.prim.lambda.closure}.
+
+\pnum
+If a \grammarterm{lambda-expression} does not include a
+\grammarterm{lambda-declarator}, it is as if the \grammarterm{lambda-declarator} were
+\tcode{()}.
+The lambda return type is \tcode{auto}, which is replaced by the
+type specified by the
+\grammarterm{trailing-return-type} if provided and/or deduced from
+\tcode{return} statements as described in~\ref{dcl.spec.auto}.
+\begin{example}
+\begin{codeblock}
+auto x1 = [](int i){ return i; };     // OK: return type is \tcode{int}
+auto x2 = []{ return { 1, 2 }; };     // error: deducing return type from \grammarterm{braced-init-list}
+int j;
+auto x3 = []()->auto&& { return j; }; // OK: return type is \tcode{int\&}
+\end{codeblock}
+\end{example}
+
+\rSec3[expr.prim.lambda.closure]{Closure types}%
+
+\pnum
 The closure type is declared in the smallest block
 scope, class scope, or namespace scope that contains the corresponding
 \grammarterm{lambda-expression}. \begin{note} This determines the set of namespaces and
 classes associated with the closure type~(\ref{basic.lookup.argdep}). The parameter
 types of a \grammarterm{lambda-declarator} do not affect these associated namespaces and
-classes. \end{note} An implementation may define the closure type differently from what
+classes. \end{note} The closure type is not an aggregate type~(\ref{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:
 
@@ -731,23 +752,6 @@
 An implementation shall not add members of rvalue reference type to the closure
 type.
 
-\pnum
-If a \grammarterm{lambda-expression} does not include a
-\grammarterm{lambda-declarator}, it is as if the \grammarterm{lambda-declarator} were
-\tcode{()}.
-The lambda return type is \tcode{auto}, which is replaced by the
-type specified by the
-\grammarterm{trailing-return-type} if provided and/or deduced from
-\tcode{return} statements as described in~\ref{dcl.spec.auto}.
-\begin{example}
-\begin{codeblock}
-auto x1 = [](int i){ return i; };     // OK: return type is \tcode{int}
-auto x2 = []{ return { 1, 2 }; };     // error: deducing return type from \grammarterm{braced-init-list}
-int j;
-auto x3 = []()->auto&& { return j; }; // OK: return type is \tcode{int\&}
-\end{codeblock}
-\end{example}
-
 \pnum
 The closure type for a non-generic \grammarterm{lambda-expression} has a public
 inline function call operator~(\ref{over.call}) whose parameters and return type
@@ -788,7 +792,9 @@
 q();                                                   // OK: outputs \tcode{1a3.14}
 \end{codeblock}
 \end{example}
-This function call operator or operator template is declared
+
+\pnum
+The function call operator or operator template is declared
 \tcode{const}~(\ref{class.mfct.non-static}) if and only if the
 \grammarterm{lambda-expression}'s \grammarterm{parameter-declaration-clause} is not
 followed by \tcode{mutable}. It is neither virtual nor declared \tcode{volatile}. Any
@@ -839,6 +845,8 @@
 the pointer to function shall behave as if it were a
 \grammarterm{decltype-specifier} denoting the return type of the corresponding
 function call operator template specialization.
+
+\pnum
 \begin{note}
 If the generic lambda has no \grammarterm{trailing-return-type} or
 the \grammarterm{trailing-return-type} contains a placeholder type, return type
@@ -889,6 +897,7 @@
 \end{codeblock}
 \end{example}
 
+\pnum
 The value returned by any given specialization of this conversion function
 template is the address of a function \tcode{F} that, when invoked, has the same
 effect as invoking the generic lambda's corresponding function call operator
@@ -908,6 +917,7 @@
 \end{codeblock}
 \end{example}
 
+\pnum
 The conversion function or conversion function template is public,
 constexpr, non-virtual, non-explicit, const, and has a non-throwing exception
 specification~(\ref{except.spec}).
@@ -950,6 +960,25 @@
 the \grammarterm{compound-statement} of the \grammarterm{lambda-expression},
 with semantics as described in~\ref{dcl.fct.def.general}.
 
+\pnum
+The closure type associated with a \grammarterm{lambda-expression} has no
+default constructor and a deleted copy assignment operator. It has a
+defaulted copy constructor and a defaulted move constructor~(\ref{class.copy}).
+\begin{note} These special member functions are implicitly defined as
+usual, and might therefore be defined as deleted. \end{note}
+
+\pnum
+The closure type associated with a \grammarterm{lambda-expression} has an
+implicitly-declared destructor~(\ref{class.dtor}).
+
+\pnum
+A member of a closure type shall not be
+explicitly instantiated~(\ref{temp.explicit}),
+explicitly specialized~(\ref{temp.expl.spec}), or
+named in a \tcode{friend} declaration~(\ref{class.friend}).
+
+\rSec3[expr.prim.lambda.capture]{Captures}%
+
 \pnum
 If a \grammarterm{lambda-capture} includes a \grammarterm{capture-default} that
 is \tcode{\&}, no identifier in a \grammarterm{simple-capture} of that
@@ -1263,23 +1292,6 @@
 \end{codeblock}
 \end{example}
 
-\pnum
-The closure type associated with a \grammarterm{lambda-expression} has no
-default constructor and a deleted copy assignment operator. It has a
-defaulted copy constructor and a defaulted move constructor~(\ref{class.copy}).
-\begin{note} These special member functions are implicitly defined as
-usual, and might therefore be defined as deleted. \end{note}
-
-\pnum
-The closure type associated with a \grammarterm{lambda-expression} has an
-implicitly-declared destructor~(\ref{class.dtor}).
-
-\pnum
-A member of a closure type shall not be
-explicitly instantiated~(\ref{temp.explicit}),
-explicitly specialized~(\ref{temp.expl.spec}), or
-named in a \tcode{friend} declaration~(\ref{class.friend}).
-
 \pnum
 When the \grammarterm{lambda-expression} is evaluated, the entities that are
 captured by copy are used to direct-initialize each corresponding non-static data member