P0780R2 Allow pack expansion in lambda init-capture

Updated a few additional places that still used "parameter pack" but
meant "pack" or a specific kind of pack to use the right term.

Author: zygoloid

source/basic.tex

@@ -31,7 +31,7 @@
 structured binding,
 function, enumerator, type,
 class member, bit-field, template, template specialization, namespace, or
-parameter pack.
+pack.
 
 \pnum
 A \defn{name} is a use of an \grammarterm{identifier}\iref{lex.name},

source/declarators.tex

@@ -1633,14 +1633,14 @@
 \pnum
 A \grammarterm{declarator-id} or \grammarterm{abstract-declarator}
 containing an ellipsis shall only
-be used in a \grammarterm{parameter-declaration}. Such a
-\grammarterm{parameter-declaration} is a parameter
-pack\iref{temp.variadic}. When it is part of a
-\grammarterm{parameter-declaration-clause}, the parameter pack is a
-function parameter pack\iref{temp.variadic}. \begin{note}
+be used in a \grammarterm{parameter-declaration}.
+When it is part of a
+\grammarterm{parameter-declaration-clause},
+the \grammarterm{parameter-declaration} declares a
+function parameter pack\iref{temp.variadic}.
 Otherwise, the \grammarterm{parameter-declaration} is part of a
-\grammarterm{template-parameter-list} and the parameter pack is a
-template parameter pack; see~\ref{temp.param}. \end{note}
+\grammarterm{template-parameter-list} and declares a
+template parameter pack; see~\ref{temp.param}.
 A function parameter pack is a pack expansion\iref{temp.variadic}.
 \begin{example}
 
@@ -1713,7 +1713,9 @@
 \grammarterm{template-parameter}\iref{temp.param};
 in the latter case, the \grammarterm{initializer-clause} shall be an
 \grammarterm{assignment-expression}.
-A default argument shall not be specified for a parameter pack.
+A default argument shall not be specified for
+a template parameter pack or
+a function parameter pack.
 If it is specified in a
 \grammarterm{parameter-declaration-clause},
 it shall not occur within a

source/expressions.tex

@@ -1229,14 +1229,15 @@
 
 \begin{bnf}
 \nontermdef{capture-list}\br
-    capture \opt{\terminal{...}}\br
-    capture-list \terminal{,} capture \opt{\terminal{...}}
+    capture\br
+    capture-list \terminal{,} capture
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{capture}\br
-    simple-capture\br
-    init-capture
+    simple-capture \opt{\terminal{...}}\br
+    % FIXME: This is wrong. The ... should go after the &.
+    \opt{\terminal{...}} init-capture
 \end{bnf}
 
 \begin{bnf}
@@ -1642,14 +1643,22 @@
 
 \pnum
 A \grammarterm{simple-capture} followed by an ellipsis is a pack
-expansion\iref{temp.variadic}. An \grammarterm{init-capture} followed by an
-ellipsis is ill-formed.
+expansion\iref{temp.variadic}.
+\indextext{init-capture pack@\fakegrammarterm{init-capture} pack}%
+An \grammarterm{init-capture} preceded by an ellipsis is a pack
+expansion that introduces an
+\grammarterm{init-capture} pack\iref{temp.variadic}
+whose declarative region is
+the \grammarterm{lambda-expression}'s \grammarterm{compound-statement}.
 \begin{example}
 \begin{codeblock}
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
   lm();
+
+  auto lm2 = [...xs=std::move(args)] { return g(xs...); };
+  lm2();
 }
 \end{codeblock}
 \end{example}%
@@ -1659,7 +1668,7 @@
 \indextext{expression!fold|(}
 
 \pnum
-A fold expression performs a fold of a template parameter
+A fold expression performs a fold of a
 pack\iref{temp.variadic} over a binary operator.
 
 \begin{bnf}
@@ -1692,7 +1701,7 @@
 are collectively called \defnx{unary folds}{unary fold}.
 In a unary fold,
 the \grammarterm{cast-expression}
-shall contain an unexpanded parameter pack\iref{temp.variadic}.
+shall contain an unexpanded pack\iref{temp.variadic}.
 
 \pnum
 \indextext{fold!binary}%
@@ -1704,13 +1713,13 @@
 \placeholder{op1} and \placeholder{op2}
 shall be the same \grammarterm{fold-operator},
 and either \tcode{e1}
-shall contain an unexpanded parameter pack
+shall contain an unexpanded pack
 or \tcode{e2}
-shall contain an unexpanded parameter pack,
+shall contain an unexpanded pack,
 but not both.
-If \tcode{e2} contains an unexpanded parameter pack,
+If \tcode{e2} contains an unexpanded pack,
 the expression is called a \defn{binary left fold}.
-If \tcode{e1} contains an unexpanded parameter pack,
+If \tcode{e1} contains an unexpanded pack,
 the expression is called a \defn{binary right fold}.
 \begin{example}
 \begin{codeblock}
@@ -1721,7 +1730,7 @@
 
 template<typename ...Args>
 bool f(Args ...args) {
-  return (args + ... + args);   // error: both operands contain unexpanded parameter packs
+  return (args + ... + args);   // error: both operands contain unexpanded packs
 }
 \end{codeblock}
 \end{example}
@@ -3639,9 +3648,9 @@
 is applied.
 
 \pnum
-The identifier in a \tcode{sizeof...} expression shall name a parameter
-pack. The \tcode{sizeof...} operator yields the number of arguments
-provided for the parameter pack \grammarterm{identifier}.
+The identifier in a \tcode{sizeof...} expression shall name a
+pack. The \tcode{sizeof...} operator yields the number of elements
+in the pack\iref{temp.variadic}.
 A \tcode{sizeof...} expression is a pack expansion\iref{temp.variadic}.
 \begin{example}
 

source/templates.tex

@@ -735,15 +735,15 @@
 If a \grammarterm{template-parameter} is a
 \grammarterm{type-parameter} with an ellipsis prior to its
 optional \grammarterm{identifier} or is a
-\grammarterm{parameter-declaration} that declares a parameter
+\grammarterm{parameter-declaration} that declares a
 pack\iref{dcl.fct}, then the \grammarterm{template-parameter}
 is a template parameter pack\iref{temp.variadic}.
 A template parameter pack that is a \grammarterm{parameter-declaration} whose type
-contains one or more unexpanded parameter packs is a pack expansion. Similarly,
+contains one or more unexpanded packs is a pack expansion. Similarly,
 a template parameter pack that is a \grammarterm{type-parameter} with a
 \grammarterm{template-parameter-list} containing one or more unexpanded
-parameter packs is a pack expansion. A template parameter pack that is a pack
-expansion shall not expand a parameter pack declared in the same
+packs is a pack expansion. A template parameter pack that is a pack
+expansion shall not expand a template parameter pack declared in the same
 \grammarterm{template-parameter-list}.
 \begin{example}
 \begin{codeblock}
@@ -1418,7 +1418,7 @@
 \pnum A \grammarterm{template-argument} matches a template
 \grammarterm{template-parameter} \tcode{P} when
 \tcode{P} is at least as specialized as the \grammarterm{template-argument} \tcode{A}.
-If \tcode{P} contains a parameter pack, then \tcode{A} also matches \tcode{P}
+If \tcode{P} contains a template parameter pack, then \tcode{A} also matches \tcode{P}
 if each of \tcode{A}'s template parameters
 matches the corresponding template parameter in the
 \grammarterm{template-head} of \tcode{P}.
@@ -1514,7 +1514,7 @@
 for each template parameter \tcode{PP}
 in the \grammarterm{template-head} of the function template,
 a corresponding template argument \tcode{AA} is formed.
-If \tcode{PP} declares a parameter pack,
+If \tcode{PP} declares a template parameter pack,
 then \tcode{AA} is the pack expansion \tcode{PP...}\iref{temp.variadic};
 otherwise, \tcode{AA} is the \grammarterm{id-expression} \tcode{PP}.
 \end{itemize}
@@ -2531,15 +2531,40 @@
 \begin{codeblock}
 template<class ... Types> void f(Types ... args);
 
-f();                            // OK: \tcode{args} contains no arguments
-f(1);                           // OK: \tcode{args} contains one argument: \tcode{int}
-f(2, 1.0);                      // OK: \tcode{args} contains two arguments: \tcode{int} and \tcode{double}
+f();                            // \tcode{args} contains no arguments
+f(1);                           // \tcode{args} contains one argument: \tcode{int}
+f(2, 1.0);                      // \tcode{args} contains two arguments: \tcode{int} and \tcode{double}
 \end{codeblock}
 \end{example}
 
 \pnum
-A \defn{parameter pack} is either a template parameter
-pack or a function parameter pack.
+An \defnx{\grammarterm{init-capture} pack}{init-capture pack@\fakegrammarterm{init-capture} pack}
+introduces an \grammarterm{init-capture}
+for each of the elements in the pack expansion of its \grammarterm{initializer}.
+\begin{example}
+\begin{codeblock}
+template <typename... Args>
+void foo(Args... args) {
+    [...xs=args]{
+        bar(xs...);             // \tcode{xs} is an \grammarterm{init-capture} pack
+    };
+}
+
+foo();                          // \tcode{xs} contains zero \grammarterm{init-captures}
+foo(1);                         // \tcode{xs} contains one \grammarterm{init-capture}
+\end{codeblock}
+\end{example}
+
+\pnum
+A \defn{pack} is
+a template parameter pack,
+a function parameter pack,
+or an \grammarterm{init-capture} pack.
+The number of elements of a template parameter pack
+or a function parameter pack
+is the number of arguments provided for the parameter pack \grammarterm{identifier}.
+The number of elements of an \grammarterm{init-capture} pack
+is the number of elements in the pack expansion of its \grammarterm{initializer}.
 
 \pnum
 \indextext{pattern|see{pack expansion, pattern}}%
@@ -2595,7 +2620,7 @@
 
 \item In a \grammarterm{fold-expression}\iref{expr.prim.fold};
 the pattern is the \grammarterm{cast-expression}
-that contains an unexpanded parameter pack.
+that contains an unexpanded pack.
 \end{itemize}
 
 \begin{example}
@@ -2608,20 +2633,20 @@
 \end{example}
 
 \pnum
-For the purpose of determining whether a parameter pack satisfies a rule
-regarding entities other than parameter packs, the parameter pack is
+For the purpose of determining whether a pack satisfies a rule
+regarding entities other than packs, the pack is
 considered to be the entity that would result from an instantiation of
 the pattern in which it appears.
 
 \pnum
-A parameter pack whose name appears within the pattern of a pack
+A pack whose name appears within the pattern of a pack
 expansion is expanded by that pack expansion. An appearance of the name of
-a parameter pack is only expanded by the innermost enclosing pack expansion.
-The pattern of a pack expansion shall name one or more parameter packs that
-are not expanded by a nested pack expansion; such parameter packs are called
-\defnx{unexpanded parameter packs}{parameter pack!unexpanded} in the pattern. All of the parameter packs expanded
+a pack is only expanded by the innermost enclosing pack expansion.
+The pattern of a pack expansion shall name one or more packs that
+are not expanded by a nested pack expansion; such packs are called
+\defnx{unexpanded packs}{pack!unexpanded} in the pattern. All of the packs expanded
 by a pack expansion shall have the same number of arguments specified. An
-appearance of a name of a parameter pack that is not expanded is
+appearance of a name of a pack that is not expanded is
 ill-formed. \begin{example}
 
 \begin{codeblock}
@@ -2642,8 +2667,8 @@
 template<class ... Args>
   void g(Args ... args) {                   // OK: \tcode{Args} is expanded by the function parameter pack \tcode{args}
     f(const_cast<const Args*>(&args)...);   // OK: ``\tcode{Args}'' and ``\tcode{args}'' are expanded
-    f(5 ...);                               // error: pattern does not contain any parameter packs
-    f(args);                                // error: parameter pack ``\tcode{args}'' is not expanded
+    f(5 ...);                               // error: pattern does not contain any packs
+    f(args);                                // error: pack ``\tcode{args}'' is not expanded
     f(h(args ...) + args ...);              // OK: first ``\tcode{args}'' expanded within \tcode{h},
                                             // second ``\tcode{args}'' expanded within \tcode{f}
   }
@@ -2670,13 +2695,20 @@
 if the pack is a template parameter pack, the element is a template
 parameter\iref{temp.param} of the corresponding kind (type or
 non-type) designating the type or value from the template
-argument; otherwise,
+argument;
 
 \item
 if the pack is a function parameter pack, the element is an
 \grammarterm{id-expression}
 designating the function parameter that resulted from
-the instantiation of the pattern where the pack is declared.
+the instantiation of the pattern where the pack is declared;
+otherwise
+
+\item
+if the pack is an \grammarterm{init-capture} pack,
+the element is an \grammarterm{id-expression}
+designating the variable declared by the \grammarterm{init-capture}
+that resulted from the instantiation of the pattern where the pack is declared.
 \end{itemize}
 
 All of the $\mathtt{E}_i$ become elements in the enclosing list.
@@ -2702,7 +2734,7 @@
 
 \pnum
 The instantiation of a \tcode{sizeof...} expression\iref{expr.sizeof} produces
-an integral constant containing the number of elements in the parameter pack
+an integral constant containing the number of elements in the pack
 it expands.
 
 \pnum
@@ -2745,7 +2777,7 @@
 For a binary fold-expression,
 $\mathtt{E}$ is generated
 by instantiating the \grammarterm{cast-expression}
-that did not contain an unexpanded parameter pack.
+that did not contain an unexpanded pack.
 \begin{example}
 \begin{codeblock}
 template<typename ...Args>
@@ -2766,7 +2798,7 @@
 \begin{floattable}{Value of folding empty sequences}{tab:fold.empty}
 {ll}
 \topline
-\lhdr{Operator} & \rhdr{Value when parameter pack is empty} \\
+\lhdr{Operator} & \rhdr{Value when pack is empty} \\
 \capsep
 \tcode{\&\&}    & \tcode{true}   \\
 \tcode{||}      & \tcode{false}  \\
@@ -3152,7 +3184,7 @@
 The template parameter list of a specialization shall not contain default
 template argument values.\footnote{There is no way in which they could be used.}
 \item
-An argument shall not contain an unexpanded parameter pack. If
+An argument shall not contain an unexpanded pack. If
 an argument is a pack expansion\iref{temp.variadic}, it shall be
 the last argument in the template argument list.
 \end{itemize}
@@ -4739,9 +4771,9 @@
 the partial specialization enclosed in
 \tcode{<>} (or an equivalent template alias specialization).
 If the \textit{n}th template parameter is
-a parameter pack, the \textit{n}th template argument is a pack
+a template parameter pack, the \textit{n}th template argument is a pack
 expansion\iref{temp.variadic} whose pattern is the name of
-the parameter pack.
+the template parameter pack.
 \end{itemize}
 
 \pnum
@@ -7209,7 +7241,7 @@
 \begin{note}
 Type deduction may fail for the following reasons:
 \begin{itemize}
-\item Attempting to instantiate a pack expansion containing multiple parameter packs of differing lengths.
+\item Attempting to instantiate a pack expansion containing multiple packs of differing lengths.
 \item
 Attempting to create an array with an element type that is \tcode{void}, a
 function type, a reference type, or an abstract class type, or attempting
@@ -7391,7 +7423,7 @@
 Each deduction deduces template arguments for subsequent positions in
 the template parameter packs expanded by the function parameter pack.
 When a function parameter pack appears in a non-deduced
-context\iref{temp.deduct.type}, the type of that parameter pack is
+context\iref{temp.deduct.type}, the type of that pack is
 never deduced.
 \begin{example}
 \begin{codeblock}