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

Files changed (1) hide show

tmp/tmpfi30ylwc/{from.md → to.md} +127 -93

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

@@ -26,13 +26,14 @@ void g(double d) {
 ```
 — *end example*]
 When an explicit template argument list is specified, if the given
-*template-id* is not valid [[temp.names]], type deduction fails.
-Otherwise, the specified template argument values are substituted for
-the corresponding template parameters as specified below.
 After this substitution is performed, the function parameter type
 adjustments described in  [[dcl.fct]] are performed.
 [*Example 2*: A parameter type of “`void (const int, int[5])`” becomes
@@ -157,29 +158,33 @@ when any template arguments that were deduced or obtained from default
 arguments are substituted.
 The *deduction substitution loci* are
 - the function type outside of the *noexcept-specifier*,
-- the *explicit-specifier*, and
-- the template parameter declarations.
 The substitution occurs in all types and expressions that are used in
 the deduction substitution loci. The expressions include not only
 constant expressions such as those that appear in array bounds or as
-nontype template arguments but also general expressions (i.e.,
 non-constant expressions) inside `sizeof`, `decltype`, and other
 contexts that allow non-constant expressions. The substitution proceeds
 in lexical order and stops when a condition that causes deduction to
 fail is encountered. If substitution into different declarations of the
 same function template would cause template instantiations to occur in a
 different order or not at all, the program is ill-formed; no diagnostic
 required.
-[*Note 4*: The equivalent substitution in exception specifications is
-done only when the *noexcept-specifier* is instantiated, at which point
-a program is ill-formed if the substitution results in an invalid type
-or expression. — *end note*]
 [*Example 6*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
@@ -217,13 +222,12 @@ effects such as the instantiation of class template specializations
 and/or function template specializations, the generation of
 implicitly-defined functions, etc. Such effects are not in the
 “immediate context” and can result in the program being
 ill-formed. — *end note*]
-A *lambda-expression* appearing in a function type or a template
-parameter is not considered part of the immediate context for the
-purposes of template argument deduction.
 [*Note 7*:
 The intent is to avoid requiring implementations to deal with
 substitution failure involving arbitrary statements.
@@ -308,11 +312,12 @@ Type deduction can fail for the following reasons:
   *qualified-id* when that type does not contain the specified member,
   or
   - the specified member is not a type where a type is required, or
   - the specified member is not a template where a template is required,
     or
-  - the specified member is not a non-type where a non-type is required.
   \[*Example 11*:
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
@@ -330,11 +335,11 @@ Type deduction can fail for the following reasons:
   int main() {
     // Deduction fails in each of these cases:
     f<A>(0);          // A does not contain a member Y
     f<B>(0);          // The Y member of B is not a type
-    g<C>(0);          // The N member of C is not a non-type
     h<D>(0);          // The TT member of D is not a template
   }
   ```
   — *end example*]
@@ -347,19 +352,19 @@ Type deduction can fail for the following reasons:
   template <class T> int f(int T::*);
   int i = f<int>(0);
   ```
   — *end example*]
-- Attempting to give an invalid type to a non-type template parameter.
   \[*Example 13*:
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T{}>*);   // #1
   class X {
     int m;
   };
-  int i0 = f<X>(0);   // #1 uses a value of non-structural type X as a non-type template argument
   ```
   — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
@@ -372,10 +377,13 @@ Type deduction can fail for the following reasons:
   — *end example*]
 - Attempting to create a function type in which a parameter has a type
   of `void`, or in which the return type is a function type or array
   type.
 — *end note*]
 [*Example 15*:
@@ -395,23 +403,23 @@ int i2 = f<1>(0);               // ambiguous; not narrowing
 — *end example*]
 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
-parameter type (call it `P`) that contains *template-parameter*s that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
-`std::initializer_list<P^{\prime}>` or `P`'`[N]` for some `P`' and `N`
-and the argument is a non-empty initializer list [[dcl.init.list]], then
-deduction is performed instead for each element of the initializer list
-independently, taking `P`' as separate function template parameter types
-`P`'_i and the iᵗʰ initializer element as the corresponding argument. In
-the `P`'`[N]` case, if `N` is a non-type template parameter, `N` is
-deduced from the length of the initializer list. Otherwise, an
-initializer list argument causes the parameter to be considered a
-non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
@@ -549,19 +557,20 @@ that allow a difference:
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
-- If `P` is a class and `P` has the form *simple-template-id*, then the
- transformed `A` can be a derived class `D` of the deduced `A`.
- Likewise, if `P` is a pointer to a class of the form
- *simple-template-id*, the transformed `A` can be a pointer to a
- derived class `D` pointed to by the deduced `A`. However, if there is
- a class `C` that is a (direct or indirect) base class of `D` and
- derived (directly or indirectly) from a class `B` and that would be a
- valid deduced `A`, the deduced `A` cannot be `B` or pointer to `B`,
- respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
@@ -580,11 +589,11 @@ that allow a difference:
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
-[*Note 1*: If a *template-parameter* is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
@@ -593,14 +602,14 @@ pointer-to-member-function type:
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
-  members of the set. If deduction succeeds for only one of the overload
- set members, that member is used as the argument value for the
- deduction. If deduction succeeds for more than one member of the
- overload set the parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
@@ -634,10 +643,26 @@ template <class T> T g(T);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
 #### Deducing template arguments taking the address of a function template <a id="temp.deduct.funcaddr">[[temp.deduct.funcaddr]]</a>
 Template arguments can be deduced from the type specified when taking
 the address of an overload set [[over.over]]. If there is a target, the
 function template’s function type and the target type are used as the
@@ -717,11 +742,11 @@ as the parameter template.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
-  parameter types for which the function call has arguments.[^13]
 - In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts [[temp.func.order]] the function template’s function
   type is used.
@@ -844,13 +869,13 @@ g(Tuple<int>());                // calls #3
 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
-value for a non-type parameter, or a template for a template parameter)
-that will make `P`, after substitution of the deduced values (call it
-the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
@@ -860,52 +885,57 @@ pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
 deduction fails. The type of a type parameter is only deduced from an
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
-templates, and non-type values:
 - A function type includes the types of each of the function parameters,
   the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
-  includes the types, templates, and non-type values referenced by the
-  template argument list of the specialization.
 - An array type includes the array element type and the value of the
   array bound.
-In most cases, the types, templates, and non-type values that are used
-to compose `P` participate in template argument deduction. That is, they
-may be used to determine the value of a template argument, and template
-argument deduction fails if the value so determined is not consistent
-with the values determined elsewhere. In certain contexts, however, the
-value does not participate in type deduction, but instead uses the
-values of template arguments that were either deduced elsewhere or
-explicitly specified. If a template parameter is used only in
-non-deduced contexts and is not explicitly specified, template argument
-deduction fails.
-[*Note 1*: Under [[temp.deduct.call]], if `P` contains no
-*template-parameter*s that appear in deduced contexts, no deduction is
-done, so `P` and `A` need not have the same form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - The *expression* of a *decltype-specifier*.
-- A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
 - A function parameter for which the associated argument is an overload
-  set [[over.over]], and one or more of the following apply:
-  - more than one function matches the function parameter type
     (resulting in an ambiguous deduction), or
-  - no function matches the function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
@@ -1014,13 +1044,15 @@ void t() {
 }
 ```
 — *end example*]
-A template type argument `T`, a template template argument `TT`, or a
-template non-type argument `i` can be deduced if `P` and `A` have one of
-the following forms:
 ``` cpp
 \opt{cv} T
 T*
 T&
@@ -1029,47 +1061,48 @@ T&&
 \opt{T}(\opt{T}) noexcept(\opt{i})
 \opt{T} \opt{T}::*
 \opt{TT}<T>
 \opt{TT}<i>
 \opt{TT}<TT>
 \opt{TT}<>
 ```
 where
 - `\opt{T}` represents a type or parameter-type-list that either
   satisfies these rules recursively, is a non-deduced context in `P` or
   `A`, or is the same non-dependent type in `P` and `A`,
-- `\opt{TT}` represents either a class template or a template template
-  parameter,
 - `\opt{i}` represents an expression that either is an `i`, is
   value-dependent in `P` or `A`, or has the same constant value in `P`
-  and `A`, and
 - `noexcept(\opt{i})` represents an exception specification
   [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
   *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
   above.
 [*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
 `TT`s, deduction is not possible. — *end note*]
-Similarly, `<T>` represents template argument lists where at least one
-argument contains a `T`, `<i>` represents template argument lists where
-at least one argument contains an `i` and `<>` represents template
-argument lists where no argument contains a `T` or an `i`.
-If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
-the respective template argument list of `P` is compared with the
-corresponding argument Aᵢ of the corresponding template argument list of
-`A`. If the template argument list of `P` contains a pack expansion that
-is not the last template argument, the entire template argument list is
-a non-deduced context. If `Pᵢ` is a pack expansion, then the pattern of
-`Pᵢ` is compared with each remaining argument in the template argument
-list of `A`. Each comparison deduces template arguments for subsequent
-positions in the template parameter packs expanded by `Pᵢ`. During
-partial ordering [[temp.deduct.partial]], if `Aᵢ` was originally a pack
-expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
@@ -1170,11 +1203,11 @@ where type is `X<int>` and `T` is `char[6]`.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
-When the value of the argument corresponding to a non-type template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
@@ -1261,12 +1294,12 @@ void g() {
 — *end note*]
 [*Note 5*:
-If, in the declaration of a function template with a non-type template
-parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 [*Example 12*:
@@ -1307,13 +1340,14 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 — *end note*]
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
-named by the enclosing *simple-template-id*, deduction fails. If `P` has
-a form that contains `[i]`, and if the type of `i` is not an integral
-type, deduction fails.[^14]
 If `P` has a form that includes `noexcept(i)` and the type of `i` is not
 `bool`, deduction fails.
 [*Example 13*:
@@ -1373,11 +1407,11 @@ void g() {
 }
 ```
 — *end example*]
-The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
 [*Example 16*:

 ```
 — *end example*]
 When an explicit template argument list is specified, if the given
+*template-id* or *splice-specialization-specifier* is not valid
+[[temp.names]], type deduction fails. Otherwise, the specified template
+argument values are substituted for the corresponding template
+parameters as specified below.
 After this substitution is performed, the function parameter type
 adjustments described in  [[dcl.fct]] are performed.
 [*Example 2*: A parameter type of “`void (const int, int[5])`” becomes
 arguments are substituted.
 The *deduction substitution loci* are
 - the function type outside of the *noexcept-specifier*,
+- the *explicit-specifier*,
+- the template parameter declarations, and
+- the template argument list of a partial specialization
+  [[temp.spec.partial.general]].
 The substitution occurs in all types and expressions that are used in
 the deduction substitution loci. The expressions include not only
 constant expressions such as those that appear in array bounds or as
+constant template arguments but also general expressions (i.e.,
 non-constant expressions) inside `sizeof`, `decltype`, and other
 contexts that allow non-constant expressions. The substitution proceeds
 in lexical order and stops when a condition that causes deduction to
 fail is encountered. If substitution into different declarations of the
 same function template would cause template instantiations to occur in a
 different order or not at all, the program is ill-formed; no diagnostic
 required.
+[*Note 4*: The equivalent substitution in exception specifications
+[[except.spec]] and function contract assertions [[dcl.contract.func]]
+is done only when the *noexcept-specifier* or
+*function-contract-specifier*, respectively, is instantiated, at which
+point a program is ill-formed if the substitution results in an invalid
+type or expression. — *end note*]
 [*Example 6*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
 and/or function template specializations, the generation of
 implicitly-defined functions, etc. Such effects are not in the
 “immediate context” and can result in the program being
 ill-formed. — *end note*]
+When substituting into a *lambda-expression*, substitution into its body
+is not in the immediate context.
 [*Note 7*:
 The intent is to avoid requiring implementations to deal with
 substitution failure involving arbitrary statements.
   *qualified-id* when that type does not contain the specified member,
   or
   - the specified member is not a type where a type is required, or
   - the specified member is not a template where a template is required,
     or
+  - the specified member is not a non-type, non-template where a
+    non-type, non-template is required.
   \[*Example 11*:
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
   int main() {
     // Deduction fails in each of these cases:
     f<A>(0);          // A does not contain a member Y
     f<B>(0);          // The Y member of B is not a type
+    g<C>(0);          // The N member of C is not a non-type, non-template name
     h<D>(0);          // The TT member of D is not a template
   }
   ```
   — *end example*]
   template <class T> int f(int T::*);
   int i = f<int>(0);
   ```
   — *end example*]
+- Attempting to give an invalid type to a constant template parameter.
   \[*Example 13*:
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T{}>*);   // #1
   class X {
     int m;
   };
+  int i0 = f<X>(0);   // #1 uses a value of non-structural type X as a constant template argument
   ```
   — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
   — *end example*]
 - Attempting to create a function type in which a parameter has a type
   of `void`, or in which the return type is a function type or array
   type.
+- Attempting to give to an explicit object parameter of a lambda’s
+  function call operator a type not permitted for such
+  [[expr.prim.lambda.closure]].
 — *end note*]
 [*Example 15*:
 — *end example*]
 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
+parameter type (call it `P`) that contains template parameters that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
+$\tcode{std::initializer_list<P}^{\prime}\tcode{>}$ or `P`'`[N]` for
+some `P`' and `N` and the argument is a non-empty initializer list
+[[dcl.init.list]], then deduction is performed instead for each element
+of the initializer list independently, taking `P`' as separate function
+template parameter types `P`'_i and the iᵗʰ initializer element as the
+corresponding argument. In the `P`'`[N]` case, if `N` is a constant
+template parameter, `N` is deduced from the length of the initializer
+list. Otherwise, an initializer list argument causes the parameter to be
+considered a non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
+- If `P` is a class and `P` has the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, then the transformed
+  `A` can be a derived class `D` of the deduced `A`. Likewise, if `P` is
+ a pointer to a class of the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, the transformed `A`
+ can be a pointer to a derived class `D` of the class pointed to by the
+ deduced `A`. However, if there is a class `C` that is a (direct or
+ indirect) base class of `D` and derived (directly or indirectly) from
+ a class `B` and that would be a valid deduced `A`, the deduced `A`
+  cannot be `B` or pointer to `B`, respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
+[*Note 1*: If a template parameter is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
+  members of the set whose associated constraints [[temp.constr.constr]]
+ are satisfied. If all successful deductions yield the same deduced
+ `A`, that deduced `A` is the result of deduction; otherwise, the
+  parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
+[*Example 9*:
+``` cpp
+// All arguments for placeholder type deduction[dcl.type.auto.deduct] yield the same deduced type.
+template<bool B> struct X {
+  static void f(short) requires B;  // #1
+  static void f(short);             // #2
+};
+void test() {
+  auto x = &X<true>::f;     // OK, deduces void(*)(short), selects #1
+  auto y = &X<false>::f;    // OK, deduces void(*)(short), selects #2
+}
+```
+— *end example*]
 #### Deducing template arguments taking the address of a function template <a id="temp.deduct.funcaddr">[[temp.deduct.funcaddr]]</a>
 Template arguments can be deduced from the type specified when taking
 the address of an overload set [[over.over]]. If there is a target, the
 function template’s function type and the target type are used as the
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
+  parameter types for which the function call has arguments.[^12]
 - In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts [[temp.func.order]] the function template’s function
   type is used.
 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
+value for a constant template parameter, or a template for a template
+template parameter) that will make `P`, after substitution of the
+deduced values (call it the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
 remains neither deduced nor explicitly specified, template argument
 deduction fails. The type of a type parameter is only deduced from an
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
+templates, and constant template argument values:
 - A function type includes the types of each of the function parameters,
   the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
+  includes the types, templates, and constant template argument values
+ referenced by the template argument list of the specialization.
 - An array type includes the array element type and the value of the
   array bound.
+In most cases, the types, templates, and constant template argument
+values that are used to compose `P` participate in template argument
+deduction. That is, they may be used to determine the value of a
+template argument, and template argument deduction fails if the value so
+determined is not consistent with the values determined elsewhere. In
+certain contexts, however, the value does not participate in type
+deduction, but instead uses the values of template arguments that were
+either deduced elsewhere or explicitly specified. If a template
+parameter is used only in non-deduced contexts and is not explicitly
+specified, template argument deduction fails.
+[*Note 1*: Under [[temp.deduct.call]], if `P` contains no template
+parameters that appear in deduced contexts, no deduction is done, so `P`
+and `A` need not have the same form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
+- A *pack-index-specifier* or a *pack-index-expression*.
+- A *type-constraint*.
 - The *expression* of a *decltype-specifier*.
+- The *constant-expression* of a *splice-specifier*.
+- A constant template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
 - A function parameter for which the associated argument is an overload
+  set such that one or more of the following apply:
+  - functions whose associated constraints are satisfied and that do not
+    all have the same function type match the function parameter type
     (resulting in an ambiguous deduction), or
+  - no function whose associated constraints are satisfied matches the
+    function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
 }
 ```
 — *end example*]
+A type template argument `T`, a constant template argument `i`, a
+template template argument `TT` denoting a class template or an alias
+template, or a template template argument `VV` denoting a variable
+template or a concept can be deduced if `P` and `A` have one of the
+following forms:
 ``` cpp
 \opt{cv} T
 T*
 T&
 \opt{T}(\opt{T}) noexcept(\opt{i})
 \opt{T} \opt{T}::*
 \opt{TT}<T>
 \opt{TT}<i>
 \opt{TT}<TT>
+\opt{TT}<VV>
 \opt{TT}<>
 ```
 where
 - `\opt{T}` represents a type or parameter-type-list that either
   satisfies these rules recursively, is a non-deduced context in `P` or
   `A`, or is the same non-dependent type in `P` and `A`,
 - `\opt{i}` represents an expression that either is an `i`, is
   value-dependent in `P` or `A`, or has the same constant value in `P`
+  and `A`,
+- `\opt{TT}` represents either a class template or a template template
+  parameter, and
 - `noexcept(\opt{i})` represents an exception specification
   [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
   *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
   above.
 [*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
 `TT`s, deduction is not possible. — *end note*]
+Similarly, `<X>` represents template argument lists where at least one
+argument contains an X, where X is one of `T`, `i`, `TT`, or `VV`; and
+`<>` represents template argument lists where no argument contains a
+`T`, an `i`, a `TT`, or a `VV`.
+If `P` has a form that contains `<T>`, `<i>`, `<TT>`, or `<VV>`, then
+each argument Pᵢ of the respective template argument list of `P` is
+compared with the corresponding argument Aᵢ of the corresponding
+template argument list of `A`. If the template argument list of `P`
+contains a pack expansion that is not the last template argument, the
+entire template argument list is a non-deduced context. If `Pᵢ` is a
+pack expansion, then the pattern of `Pᵢ` is compared with each remaining
+argument in the template argument list of `A`. Each comparison deduces
+template arguments for subsequent positions in the template parameter
+packs expanded by `Pᵢ`. During partial ordering [[temp.deduct.partial]],
+if `Aᵢ` was originally a pack expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
+When the value of the argument corresponding to a constant template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
 — *end note*]
 [*Note 5*:
+If, in the declaration of a function template with a constant template
+parameter, the constant template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 [*Example 12*:
 — *end note*]
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
+named by the enclosing *simple-template-id* or
+*splice-specialization-specifier*, deduction fails. If `P` has a form
+that contains `[i]`, and if the type of `i` is not an integral type,
+deduction fails.[^13]
 If `P` has a form that includes `noexcept(i)` and the type of `i` is not
 `bool`, deduction fails.
 [*Example 13*:
 }
 ```
 — *end example*]
+The *template-argument* corresponding to a template template parameter
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
 [*Example 16*:

Diff to HTML by rtfpessoa