[temp.decls] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpqltf1yce/{from.md → to.md} +124 -61

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

@@ -20,11 +20,13 @@ class templates are considered definitions; each default argument,
 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
 definition or to any other default arguments, *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
-are considered definitions.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
@@ -188,19 +190,20 @@ v2[3] = dcomplex(7,8);                  // Array<dcomplex>::operator[]
 — *end example*]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
-Deduction guides are used when a *template-name* appears as a type
-specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
-guides are not found by name lookup. Instead, when performing class
-template argument deduction [[over.match.class.deduct]], all reachable
-deduction guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
-    explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
 [*Example 1*:
 ``` cpp
@@ -219,11 +222,13 @@ S x{A()};           // x is of type S<short, int>
 ```
 — *end example*]
 The same restrictions apply to the *parameter-declaration-clause* of a
-deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
 the *simple-template-id*. A *deduction-guide* shall inhabit the scope to
 which the corresponding class template belongs and, for a member class
 template, have the same access. Two deduction guide declarations for the
@@ -300,11 +305,10 @@ class template definition.
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
-A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
 — *end example*]
@@ -413,13 +417,13 @@ class D : public B {
 — *end example*]
 [*Note 1*:
-A specialization of a conversion function template is referenced in the
-same way as a non-template conversion function that converts to the same
-type [[class.conv.fct]].
 [*Example 6*:
 ``` cpp
 struct A {
@@ -436,13 +440,15 @@ int main() {
 }
 ```
 — *end example*]
-There is no syntax to form a *template-id* [[temp.names]] by providing
-an explicit template argument list [[temp.arg.explicit]] for a
-conversion function template.
 — *end note*]
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
@@ -495,15 +501,33 @@ foo();                          // xs contains zero init-captures
 foo(1);                         // xs contains one init-capture
 ```
 — *end example*]
-A *pack* is a template parameter pack, a function parameter pack, or an
-*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. The number of elements of an *init-capture* pack is the
-number of elements in the pack expansion of its *initializer*.
 A *pack expansion* consists of a *pattern* and an ellipsis, the
 instantiation of which produces zero or more instantiations of the
 pattern in a list (described below). The form of the pattern depends on
 the context in which the expansion occurs. Pack expansions can occur in
@@ -511,15 +535,21 @@ the following contexts:
 - In a function parameter pack [[dcl.fct]]; the pattern is the
   *parameter-declaration* without the ellipsis.
 - In a *using-declaration* [[namespace.udecl]]; the pattern is a
   *using-declarator*.
 - In a template parameter pack that is a pack expansion [[temp.param]]:
   - if the template parameter pack is a *parameter-declaration*; the
     pattern is the *parameter-declaration* without the ellipsis;
   - if the template parameter pack is a *type-parameter*; the pattern is
-    the corresponding *type-parameter* without the ellipsis.
 - In an *initializer-list* [[dcl.init]]; the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* [[class.derived]]; the pattern is a
   *base-specifier*.
 - In a *mem-initializer-list* [[class.base.init]] for a
@@ -527,20 +557,26 @@ the following contexts:
   pattern is the *mem-initializer*.
 - In a *template-argument-list* [[temp.arg]]; the pattern is a
   *template-argument*.
 - In an *attribute-list* [[dcl.attr.grammar]]; the pattern is an
   *attribute*.
 - In an *alignment-specifier* [[dcl.align]]; the pattern is the
   *alignment-specifier* without the ellipsis.
 - In a *capture-list* [[expr.prim.lambda.capture]]; the pattern is the
   *capture* without the ellipsis.
 - In a `sizeof...` expression [[expr.sizeof]]; the pattern is an
   *identifier*.
 - In a *fold-expression* [[expr.prim.fold]]; the pattern is the
   *cast-expression* that contains an unexpanded pack.
-[*Example 4*:
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
@@ -560,11 +596,11 @@ a pack expansion shall name one or more packs that are not expanded by a
 nested pack expansion; such packs are called *unexpanded packs* 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 pack
 that is not expanded is ill-formed.
-[*Example 5*:
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
@@ -596,33 +632,45 @@ The instantiation of a pack expansion considers items
 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$`))`
@@ -634,11 +682,11 @@ The instantiation of a *fold-expression* [[expr.prim.fold]] produces:
 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); }
@@ -661,21 +709,23 @@ If N is zero for a unary fold, the value of the expression is shown in
 | `&&`     | `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...);
@@ -957,19 +1007,20 @@ A<int,int*> a;      // uses the partial specialization, which is found through t
                     // which refers to the primary template
 ```
 — *end example*]
-A non-type argument is non-specialized if it is the name of a non-type
-parameter. All other non-type arguments are specialized.
 Within the argument list of a partial specialization, the following
 restrictions apply:
 - The type of a template parameter corresponding to a specialized
- non-type argument shall not be dependent on a parameter of the partial
-  specialization.
   \[*Example 5*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
@@ -980,11 +1031,11 @@ restrictions apply:
   — *end example*]
 - The partial specialization shall be more specialized than the primary
   template [[temp.spec.partial.order]].
 - The template parameter list of a partial specialization shall not
-  contain default template argument values.[^8]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
@@ -1244,11 +1295,11 @@ templates and non-template functions [[dcl.fct]] in the same
 scope. — *end note*]
 A non-template function is not related to a function template (i.e., it
 is never considered to be a specialization), even if it has the same
 name and type as a potentially generated function template
-specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
@@ -1314,11 +1365,11 @@ template <int K, int L> A<K+L> f(A<K>, A<L>);   // same as #1
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
-[*Note 2*: Most expressions that use template parameters use non-type
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
@@ -1345,12 +1396,12 @@ signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
 only the name itself is considered, not the result of name lookup.
 [*Note 5*: If such a dependent name is unqualified, it is looked up
-from the first declaration of the function template
-[[temp.dep.candidate]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
@@ -1406,34 +1457,35 @@ declared with a *type-constraint*, and if either *template-head* has a
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
-- if they declare non-type template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
-- if they declare template template parameters, their template
- parameters are equivalent.
 When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
 If the validity or meaning of the program depends on whether two
 constructs are equivalent, and they are functionally equivalent but not
 equivalent, the program is ill-formed, no diagnostic required.
-Furthermore, if two function templates that do not correspond
-- have the same name,
 - have corresponding signatures [[basic.scope.scope]],
-- would declare the same entity [[basic.link]] considering them to
- correspond, and
 - accept and are satisfied by the same set of template argument lists,
-the program is ill-formed, no diagnostic required.
 [*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
@@ -1483,20 +1535,24 @@ function type. The deduction process determines whether one of the
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
-To produce the transformed template, for each type, non-type, or
-template template parameter (including template parameter packs
-[[temp.variadic]] thereof) synthesize a unique type, value, or class
-template respectively and substitute it for each occurrence of that
-parameter in the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
-synthesized for a non-type template parameter is also a unique
 synthesized type. — *end note*]
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order
@@ -1700,14 +1756,21 @@ void h() {
 A *template-declaration* in which the *declaration* is an
 *alias-declaration* [[dcl.pre]] declares the *identifier* to be an
 *alias template*. An alias template is a name for a family of types. The
 name of the alias template is a *template-name*.
-When a *template-id* refers to the specialization of an alias template,
-it is equivalent to the associated type obtained by substitution of its
-*template-argument*s for the *template-parameter*s in the
-*defining-type-id* of the alias template.
 [*Note 1*: An alias template name is never deduced. — *end note*]
 [*Example 1*:
@@ -1832,7 +1895,7 @@ specialized [[temp.expl.spec]], or partially specialized
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its
 *prototype parameter*. A *type concept* is a concept whose prototype
-parameter is a type *template-parameter*.

 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
 definition or to any other default arguments, *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
+are considered definitions. For the purpose of name lookup and
+instantiation, the *compound-statement* of an *expansion-statement* is
+considered a template definition.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
 — *end example*]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
+Deduction guides are used when a *template-name* or
+*splice-type-specifier* appears as a type specifier for a deduced class
+type [[dcl.type.class.deduct]]. Deduction guides are not found by name
+lookup. Instead, when performing class template argument deduction
+[[over.match.class.deduct]], all reachable deduction guides declared for
+the class template are considered.
 ``` bnf
 deduction-guide:
+    explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id requires-clauseₒₚₜ ';'
 ```
 [*Example 1*:
 ``` cpp
 ```
 — *end example*]
 The same restrictions apply to the *parameter-declaration-clause* of a
+deduction guide as in a function declaration [[dcl.fct]], except that a
+generic parameter type placeholder [[dcl.spec.auto]] shall not appear in
+the *parameter-declaration-clause* of a deduction guide. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
 the *simple-template-id*. A *deduction-guide* shall inhabit the scope to
 which the corresponding class template belongs and, for a member class
 template, have the same access. Two deduction guide declarations for the
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
 — *end example*]
 — *end example*]
 [*Note 1*:
+A specialization of a conversion function template is named in the same
+way as a non-template conversion function that converts to the same type
+[[class.conv.fct]].
 [*Example 6*:
 ``` cpp
 struct A {
 }
 ```
 — *end example*]
+An expression designating a particular specialization of a conversion
+function template can only be formed with a *splice-expression*. There
+is no analogous syntax to form a *template-id* [[temp.names]] for such a
+function by providing an explicit template argument list
+[[temp.arg.explicit]].
 — *end note*]
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 foo(1);                         // xs contains one init-capture
 ```
 — *end example*]
+A *structured binding pack* is an *sb-identifier* that introduces zero
+or more structured bindings [[dcl.struct.bind]].
+[*Example 4*:
+``` cpp
+auto foo() -> int(&)[2];
+template <class T>
+void g() {
+  auto [...a] = foo();          // a is a structured binding pack containing two elements
+  auto [b, c, ...d] = foo();    // d is a structured binding pack containing zero elements
+}
+```
+— *end example*]
+A *pack* is a template parameter pack, a function parameter pack, an
+*init-capture* pack, or a structured binding 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. The number of
+elements of an *init-capture* pack is the number of elements in the pack
+expansion of its *initializer*.
 A *pack expansion* consists of a *pattern* and an ellipsis, the
 instantiation of which produces zero or more instantiations of the
 pattern in a list (described below). The form of the pattern depends on
 the context in which the expansion occurs. Pack expansions can occur in
 - In a function parameter pack [[dcl.fct]]; the pattern is the
   *parameter-declaration* without the ellipsis.
 - In a *using-declaration* [[namespace.udecl]]; the pattern is a
   *using-declarator*.
+- In a *friend-type-declaration* [[class.mem.general]]; the pattern is a
+  *friend-type-specifier*.
 - In a template parameter pack that is a pack expansion [[temp.param]]:
   - if the template parameter pack is a *parameter-declaration*; the
     pattern is the *parameter-declaration* without the ellipsis;
   - if the template parameter pack is a *type-parameter*; the pattern is
+    the corresponding *type-parameter* without the ellipsis;
+  - if the template parameter pack is a template template parameter; the
+    pattern is the corresponding *type-tt-parameter*,
+    *variable-tt-parameter*, or *concept-tt-parameter* without the
+    ellipsis.
 - In an *initializer-list* [[dcl.init]]; the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* [[class.derived]]; the pattern is a
   *base-specifier*.
 - In a *mem-initializer-list* [[class.base.init]] for a
   pattern is the *mem-initializer*.
 - In a *template-argument-list* [[temp.arg]]; the pattern is a
   *template-argument*.
 - In an *attribute-list* [[dcl.attr.grammar]]; the pattern is an
   *attribute*.
+- In an *annotation-list* [[dcl.attr.grammar]]; the pattern is an
+  *annotation*.
 - In an *alignment-specifier* [[dcl.align]]; the pattern is the
   *alignment-specifier* without the ellipsis.
 - In a *capture-list* [[expr.prim.lambda.capture]]; the pattern is the
   *capture* without the ellipsis.
 - In a `sizeof...` expression [[expr.sizeof]]; the pattern is an
   *identifier*.
+- In a *pack-index-expression*; the pattern is an *identifier*.
+- In a *pack-index-specifier*; the pattern is a *typedef-name*.
 - In a *fold-expression* [[expr.prim.fold]]; the pattern is the
   *cast-expression* that contains an unexpanded pack.
+- In a fold expanded constraint [[temp.constr.fold]]; the pattern is the
+  constraint of that fold expanded constraint.
+[*Example 5*:
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
 nested pack expansion; such packs are called *unexpanded packs* 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 pack
 that is not expanded is ill-formed.
+[*Example 6*:
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
 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 *typedef-name* for a type template parameter pack,
+ - an *id-expression* for a constant template parameter pack, or
+ - a *template-name* for a template template parameter pack
+ designating the iᵗʰ corresponding type, constant, or template 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;
 - 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; otherwise
+- if the pack is a structured binding pack, the element is an
+  *id-expression* designating the $i^\textrm{th}$ structured binding in
+  the pack that resulted from the structured binding 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.
+When instantiating a *pack-index-expression* P, let K be the index of P.
+The instantiation of P is the *id-expression* `E_K`.
+When instantiating a *pack-index-specifier* P, let K be the index of P.
+The instantiation of P is the *typedef-name* `E_K`.
+The instantiation of an *alignment-specifier* with an ellipsis produces
+`E₁` `E₂` … `E_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$`))`
 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 7*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
+A fold expanded constraint is not instantiated [[temp.constr.fold]].
 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 8*:
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
                     // which refers to the primary template
 ```
 — *end example*]
+A constant template argument is non-specialized if it is the name of a
+constant template parameter. All other constant template arguments are
+specialized.
 Within the argument list of a partial specialization, the following
 restrictions apply:
 - The type of a template parameter corresponding to a specialized
+ constant template argument shall not be dependent on a parameter of
+ the partial specialization.
   \[*Example 5*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
   — *end example*]
 - The partial specialization shall be more specialized than the primary
   template [[temp.spec.partial.order]].
 - The template parameter list of a partial specialization shall not
+  contain default template argument values.[^7]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
 scope. — *end note*]
 A non-template function is not related to a function template (i.e., it
 is never considered to be a specialization), even if it has the same
 name and type as a potentially generated function template
+specialization.[^8]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
+[*Note 2*: Most expressions that use template parameters use constant
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 For determining whether two dependent names [[temp.dep]] are equivalent,
 only the name itself is considered, not the result of name lookup.
 [*Note 5*: If such a dependent name is unqualified, it is looked up
+from a first declaration of the function template
+[[temp.res.general]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
+- if they declare constant template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
+- if they declare template template parameters, their *template-head*s
+  are equivalent.
 When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
 If the validity or meaning of the program depends on whether two
 constructs are equivalent, and they are functionally equivalent but not
 equivalent, the program is ill-formed, no diagnostic required.
+Furthermore, if two declarations A and B of function templates
+- introduce the same name,
 - have corresponding signatures [[basic.scope.scope]],
+- would declare the same entity, when considering A and B to correspond
+ in that determination [[basic.link]], and
 - accept and are satisfied by the same set of template argument lists,
+but do not correspond, the program is ill-formed, no diagnostic
+required.
 [*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
+To produce the transformed template, for each type, constant, type
+template, variable template, or concept template parameter (including
+template parameter packs [[temp.variadic]] thereof) synthesize a unique
+type, value, class template, variable template, or concept,
+respectively, and substitute it for each occurrence of that parameter in
+the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
+synthesized for a constant template parameter is also a unique
 synthesized type. — *end note*]
+A synthesized template has the same *template-head* as its corresponding
+template template parameter.
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order
 A *template-declaration* in which the *declaration* is an
 *alias-declaration* [[dcl.pre]] declares the *identifier* to be an
 *alias template*. An alias template is a name for a family of types. The
 name of the alias template is a *template-name*.
+A
+- *template-id* that is not the operand of a *reflect-expression* or
+-
+that designates the specialization of an alias template is equivalent to
+the associated type obtained by substitution of its *template-argument*s
+for the *template-parameter*s in the *defining-type-id* of the alias
+template. Any other *template-id* that names a specialization of an
+alias template is a *typedef-name* for a type alias.
 [*Note 1*: An alias template name is never deduced. — *end note*]
 [*Example 1*:
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its
 *prototype parameter*. A *type concept* is a concept whose prototype
+parameter is a type template parameter.

Diff to HTML by rtfpessoa