[temp.variadic] - C++20 → C++23

Files changed (1) hide show

tmp/tmpf8r_bips/{from.md → to.md} +61 -59

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

@@ -127,94 +127,72 @@ template<class ... Args1> struct zip {
     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
-    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>{>}
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
-  void g(Args ... args) {                   // OK: Args is expanded by the function parameter pack args
-    f(const_cast<const Args*>(&args)...);   // OK: ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
-    f(h(args ...) + args ...);              // OK: first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
-The instantiation of a pack expansion that is neither a `sizeof...`
-expression nor a *fold-expression* produces a list of elements E₁, E₂,
-⋯, $\mathtt{E}_N$, where N is the number of elements in the pack
-expansion parameters. Each Eᵢ is generated by instantiating the pattern
-and replacing each pack expansion parameter with its iᵗʰ element. Such
-an element, in the context of the instantiation, is interpreted as
-follows:
-- if the pack is a template parameter pack, the element is a template
- parameter [[temp.param]] of the corresponding kind (type or non-type)
- designating the iᵗʰ corresponding type or value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
-  pack.
-All of the Eᵢ become items in the enclosing list.
-[*Note 1*: The variety of list varies with the context:
-*expression-list*, *base-specifier-list*, *template-argument-list*,
-etc. — *end note*]
-When N is zero, the instantiation of the expansion produces an empty
-list. Such an instantiation does not alter the syntactic interpretation
-of the enclosing construct, even in cases where omitting the list
-entirely would otherwise be ill-formed or would result in an ambiguity
-in the grammar.
-[*Example 6*:
-``` cpp
-template<class... T> struct X : T... { };
-template<class... T> void f(T... values) {
-  X<T...> x(values...);
-}
-template void f<>();    // OK: X<> has no base classes
-                        // x is a variable of type X<> that is value-initialized
-```
-— *end example*]
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
-an integral constant containing the number of elements in the pack it
-expands.
-The instantiation of a *fold-expression* produces:
-- `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a unary left fold,
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))` for a
-  unary right fold,
-- `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a
-  binary left fold, and
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$ *op*
-  E`)))` for a binary right fold.
-In each case, *op* is the *fold-operator*, N is the number of elements
-in the pack expansion parameters, and each Eᵢ is generated by
-instantiating the pattern and replacing each pack expansion parameter
-with its iᵗʰ element. For a binary fold-expression, E is generated by
-instantiating the *cast-expression* that did not contain an unexpanded
-pack.
-[*Example 7*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
@@ -224,12 +202,12 @@ bool b = all(true, true, true, false);
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
-If N is zero for a unary fold-expression, the value of the expression is
-shown in [[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
@@ -237,5 +215,29 @@ shown in [[temp.fold.empty]]; if the operator is not listed in
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |

     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
+    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>>
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
+  void g(Args ... args) {                   // OK, Args is expanded by the function parameter pack args
+    f(const_cast<const Args*>(&args)...);   // OK, ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
+    f(h(args ...) + args ...);              // OK, first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
+The instantiation of a pack expansion considers items
+`E₁`, `E₂`, …, `E_N`, where N is the number of elements in the pack
+expansion parameters. Each `Eᵢ` is generated by instantiating the
+pattern and replacing each pack expansion parameter with its iᵗʰ
+element. Such an element, in the context of the instantiation, is
+interpreted as follows:
+- if the pack is a template parameter pack, the element is an
+ *id-expression* (for a non-type template parameter pack), a
+ *typedef-name* (for a type template parameter pack declared without
+  `template`), or a *template-name* (for a type template parameter pack
+  declared with `template`), designating the iᵗʰ corresponding type or
+  value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
+  pack declaration.
+When N is zero, the instantiation of a pack expansion does not alter the
+syntactic interpretation of the enclosing construct, even in cases where
+omitting the pack expansion entirely would otherwise be ill-formed or
+would result in an ambiguity in the grammar.
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
+an integral constant with value N.
+The instantiation of a *fold-expression* [[expr.prim.fold]] produces:
+- `(` `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for a unary
+  left fold,
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))`
+ `)` for a unary right fold,
+- `(` `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for
+  a binary left fold, and
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$
+  *op* E`)))` `)` for a binary right fold.
+In each case, *op* is the *fold-operator*. For a binary fold, E is
+generated by instantiating the *cast-expression* that did not contain an
+unexpanded pack.
+[*Example 6*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
+If N is zero for a unary fold, the value of the expression is shown in
+[[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
+The instantiation of any other pack expansion produces a list of
+elements `E₁`, `E₂`, …, `E_N`.
+[*Note 1*: The variety of list varies with the context:
+*expression-list*, *base-specifier-list*, *template-argument-list*,
+etc. — *end note*]
+When N is zero, the instantiation of the expansion produces an empty
+list.
+[*Example 7*:
+``` cpp
+template<class... T> struct X : T... { };
+template<class... T> void f(T... values) {
+  X<T...> x(values...);
+}
+template void f<>();    // OK, X<> has no base classes
+                        // x is a variable of type X<> that is value-initialized
+```
+— *end example*]

Diff to HTML by rtfpessoa