[temp.deduct] - C++14 → C++17

Files changed (1) hide show

tmp/tmp3rwmpo6i/{from.md → to.md} +457 -155

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

@@ -3,10 +3,12 @@
 When a function template specialization is referenced, all of the
 template arguments shall have values. The values can be explicitly
 specified or, in some cases, be deduced from the use or obtained from
 default *template-argument*s.
 ``` cpp
 void f(Array<dcomplex>& cv, Array<int>& ci) {
   sort(cv);                     // calls sort(Array<dcomplex>&)
   sort(ci);                     // calls sort(Array<int>&)
 }
@@ -19,10 +21,12 @@ void g(double d) {
   int i = convert<int>(d);      // calls convert<int,double>(double)
   int c = convert<char>(d);     // calls convert<char,double>(double)
 }
 ```
 When an explicit template argument list is specified, the template
 arguments must be compatible with the template parameter list and must
 result in a valid function type as described below; otherwise type
 deduction fails. Specifically, the following steps are performed when
 evaluating an explicitly specified template argument list with respect
@@ -39,15 +43,20 @@ to a given function template:
   [[temp.arg.nontype]], otherwise type deduction fails.
 - 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. A parameter type of
-“`void ()(const int, int[5])`” becomes “`void(*)(int,int*)`”. A
-top-level qualifier in a function parameter declaration does not affect
-the function type but still affects the type of the function parameter
-variable within the function.
 ``` cpp
 template <class T> void f(T t);
 template <class X> void g(const X x);
 template <class Z> void h(Z, Z*);
@@ -68,21 +77,26 @@ int main() {
   // #5: function type is h(int, const int*)
   h<const int>(1,0);
 }
 ```
-`f<int>(1)` and `f<const int>(1)` call distinct functions even though
-both of the functions called have the same function type.
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
 argument has not been deduced and its corresponding template parameter
 has a default argument, the template argument is determined by
 substituting the template arguments determined for preceding template
 parameters into the default argument. If the substitution results in an
 invalid type, as described above, type deduction fails.
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
 void g() {
@@ -92,10 +106,12 @@ void g() {
   f<int>();         // f<int,double>(0,0)
   f<int,char>();    // f<int,char>(0,0)
 }
 ```
 When all template arguments have been deduced or obtained from default
 template arguments, all uses of template parameters in the template
 parameter list of the template and the function type are replaced with
 the corresponding deduced or default argument values. If the
 substitution results in an invalid type, as described above, type
@@ -115,14 +131,18 @@ the function type and in template parameter declarations. 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. The equivalent substitution in
-exception specifications is done only when the *exception-specification*
-is instantiated, at which point a program is ill-formed if the
-substitution results in an invalid type or expression.
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
 template <class T> typename T::X f(typename A<T>::X);
 template <class T> void f(...) { }
@@ -133,22 +153,33 @@ void h() {
   f<int>(0);        // OK, substituting return type causes deduction to fail
   g<int>(0);        // error, substituting parameter type instantiates A<int>
 }
 ```
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
 ill-formed, with a diagnostic required, if written using the substituted
-arguments. If no diagnostic is required, the program is still
-ill-formed. Access checking is done as part of the substitution process.
 Only invalid types and expressions in the immediate context of the
 function type and its template parameter types can result in a deduction
-failure. The evaluation of the substituted types and expressions can
-result in side effects such as the instantiation of class template
-specializations and/or function template specializations, the generation
-of implicitly-defined functions, etc. Such side effects are not in the
-“immediate context” and can result in the program being ill-formed.
 ``` cpp
 struct X { };
 struct Y {
   Y(X){}
@@ -159,36 +190,47 @@ X f(Y, Y);  // #2
 X x1, x2;
 X x3 = f(x1, x2);   // deduction fails on #1 (cannot add X+X), calls #2
 ```
 Type deduction may fail for the following reasons:
 - Attempting to instantiate a pack expansion containing multiple
   parameter packs of differing lengths.
 - Attempting to create an array with an element type that is `void`, a
   function type, a reference type, or an abstract class type, or
   attempting to create an array with a size that is zero or negative.
   ``` cpp
   template <class T> int f(T[5]);
   int I = f<int>(0);
   int j = f<void>(0);             // invalid array
   ```
 - Attempting to use a type that is not a class or enumeration type in a
   qualified name.
   ``` cpp
   template <class T> int f(typename T::B*);
   int i = f<int>(0);
   ```
 - Attempting to use a type in a *nested-name-specifier* of a
   *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.
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
   template <class T> void f(typename T::Y*){}
   template <class T> void g(X<T::N>*){}
@@ -208,82 +250,124 @@ Type deduction may fail for the following reasons:
     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
   }
   ```
 - Attempting to create a pointer to reference type.
 - Attempting to create a reference to `void`.
 - Attempting to create “pointer to member of `T`” when `T` is not a
   class type.
   ``` cpp
   template <class T> int f(int T::*);
   int i = f<int>(0);
   ```
 - Attempting to give an invalid type to a non-type template parameter.
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T()>*);
   struct X {};
   int i0 = f<X>(0);
   ```
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
   declaration.
   ``` cpp
   template <class T, T*> int f(int);
   int i2 = f<int,1>(0);           // can't conv 1 to int*
   ```
 - 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 create a function type in which a parameter type or the
   return type is an abstract class type ([[class.abstract]]).
-Except as described above, the use of an invalid value shall not cause
-type deduction to fail. In the following example 1000 is converted to
-`signed char` and results in an implementation-defined value as
-specified in ([[conv.integral]]). In other words, both templates are
-considered even though 1000, when converted to `signed char`, results in
-an implementation-defined value.
 ``` cpp
 template <int> int f(int);
 template <signed char> int f(int);
-int i1 = f<1>(0); // ambiguous
-int i2 = f<1000>(0); // ambiguous
 ```
 #### 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`) 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>` for some
-`P^\prime` and the argument is an initializer list ([[dcl.init.list]]),
-then deduction is performed instead for each element of the initializer
-list, taking `P^\prime` as a function template parameter type and the
-initializer element as its argument. Otherwise, an initializer list
-argument causes the parameter to be considered a non-deduced context (
-[[temp.deduct.type]]).
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
 f({1,2,3});                     // T deduced to int
 f({1,"asdf"});                  // error: T deduced to both int and const char*
 template<class T> void g(T);
 g({1,2,3});                     // error: no argument deduced for T
 ```
 For a function parameter pack that occurs at the end of the
-*parameter-declaration-list*, the type `A` of each remaining argument of
-the call is compared with the type `P` of the *declarator-id* of the
-function parameter pack. Each comparison 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 ([[temp.deduct.type]]), the type of that parameter
-pack is never deduced.
 ``` cpp
 template<class ... Types> void f(Types& ...);
 template<class T1, class ... Types> void g(T1, Types ...);
 template<class T1, class ... Types> void g1(Types ..., T1);
@@ -292,112 +376,185 @@ void h(int x, float& y) {
   const int z = x;
   f(x, y, z);                   // Types is deduced to int, float, const int
   g(x, y, z);                   // T1 is deduced to int; Types is deduced to float, int
   g1(x, y, z);                  // error: Types is not deduced
   g1<int, int, int>(x, y, z);   // OK, no deduction occurs
 }
 ```
 If `P` is not a reference type:
 - If `A` is an array type, the pointer type produced by the
   array-to-pointer standard conversion ([[conv.array]]) is used in
   place of `A` for type deduction; otherwise,
 - If `A` is a function type, the pointer type produced by the
   function-to-pointer standard conversion ([[conv.func]]) is used in
   place of `A` for type deduction; otherwise,
-- If `A` is a cv-qualified type, the top level cv-qualifiers of `A`’s
   type are ignored for type deduction.
-If `P` is a cv-qualified type, the top level cv-qualifiers of `P`’s type
 are ignored for type deduction. If `P` is a reference type, the type
-referred to by `P` is used for type deduction. If `P` is an rvalue
-reference to a cv-unqualified template parameter and the argument is an
-lvalue, the type “lvalue reference to `A`” is used in place of `A` for
-type deduction.
 ``` cpp
-template <class T> int f(T&&);
 template <class T> int g(const T&&);
 int i;
 int n1 = f(i);                  // calls f<int&>(int&)
 int n2 = f(0);                  // calls f<int>(int&&)
 int n3 = g(i);                  // error: would call g<int>(const int&&), which
                                 // would bind an rvalue reference to an lvalue
 ```
 In general, the deduction process attempts to find template argument
 values that will make the deduced `A` identical to `A` (after the type
 `A` is transformed as described above). However, there are three cases
 that allow a difference:
 - If the original `P` is a reference type, the deduced `A` (i.e., the
   type referred to by the reference) can be more cv-qualified than the
   transformed `A`.
 - The transformed `A` can be another pointer or pointer to member type
-  that can be converted to the deduced `A` via a 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 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 pointed to by the
   deduced `A`.
-as specified in  [[temp.arg.explicit]], implicit conversions will be
-performed on a function argument to convert it to the type of the
-corresponding function parameter if the parameter contains no
-*template-parameter*s that participate in template argument deduction.
-Such conversions are also allowed, in addition to the ones described in
-the preceding list.
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
-deduction fails. 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.
-When P is a function type, pointer to function type, or 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.
 ``` cpp
- // Only one function of an overload set matches the call so the function
-  // parameter is a deduced context.
 template <class T> int f(T (*p)(T));
 int g(int);
 int g(char);
 int i = f(g);       // calls f(int (*)(int))
 ```
 ``` cpp
- // Ambiguous deduction causes the second function parameter to be a
-  // non-deduced context.
 template <class T> int f(T, T (*p)(T));
 int g(int);
 char g(char);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 ``` cpp
- // The overload set contains a template, causing the second function
-  // parameter to be a non-deduced context.
 template <class T> int f(T, T (*p)(T));
 char g(char);
 template <class T> T g(T);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 #### 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 overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
@@ -427,23 +584,28 @@ If `A` is not a reference type:
   array-to-pointer standard conversion ([[conv.array]]) is used in
   place of `P` for type deduction; otherwise,
 - If `P` is a function type, the pointer type produced by the
   function-to-pointer standard conversion ([[conv.func]]) is used in
   place of `P` for type deduction; otherwise,
-- If `P` is a cv-qualified type, the top level cv-qualifiers of `P`’s
   type are ignored for type deduction.
-If `A` is a cv-qualified type, the top level cv-qualifiers of `A`’s type
 are ignored for type deduction. If `A` is a reference type, the type
 referred to by `A` is used for type deduction.
 In general, the deduction process attempts to find template argument
 values that will make the deduced `A` identical to `A`. However, there
-are two cases that allow a difference:
 - If the original `A` is a reference type, `A` can be more cv-qualified
   than the deduced `A` (i.e., the type referred to by the reference)
 - The deduced `A` can be another pointer or pointer to member type that
   can be converted to `A` via a qualification conversion.
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
@@ -455,36 +617,44 @@ process is used to determine the deduced template argument values:
 If `A` is a type
 and `P` is a type
-The cv-unqualified `T1` and `T2` are used as the types of `A` and `P`
-respectively for type deduction.
 ``` cpp
 struct A {
   template <class T> operator T***();
 };
 A a;
 const int * const * const * p1 = a;     // T is deduced as int, not const int
 ```
 #### Deducing template arguments during partial ordering <a id="temp.deduct.partial">[[temp.deduct.partial]]</a>
 Template argument deduction is done by comparing certain types
 associated with the two function templates being compared.
 Two sets of types are used to determine the partial ordering. For each
 of the templates involved there is the original function type and the
-transformed function type. The creation of the transformed type is
-described in  [[temp.func.order]]. The deduction process uses the
-transformed type as the argument template and the original type of the
-other template as the parameter template. This process is done twice for
-each type involved in the partial ordering comparison: once using the
-transformed template-1 as the argument template and template-2 as the
-parameter template and again using the transformed template-2 as the
-argument template and template-1 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
@@ -494,11 +664,13 @@ the partial ordering is done:
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
 corresponding type from the argument template are used as the types of
-`P` and `A`.
 Before the partial ordering is done, certain transformations are
 performed on the types used for partial ordering:
 - If `P` is a reference type, `P` is replaced by the type referred to.
@@ -515,70 +687,88 @@ Remove any top-level cv-qualifiers:
 - If `P` is a cv-qualified type, `P` is replaced by the cv-unqualified
   version of `P`.
 - If `A` is a cv-qualified type, `A` is replaced by the cv-unqualified
   version of `A`.
-If `A` was transformed from a function parameter pack and `P` is not a
-parameter pack, type deduction fails. Otherwise, using the resulting
-types `P` and `A`, the deduction is then done as described in
-[[temp.deduct.type]]. If `P` is a function parameter pack, the type `A`
-of each remaining parameter type of the argument template is compared
-with the type `P` of the *declarator-id* of the function parameter pack.
-Each comparison deduces template arguments for subsequent positions in
-the template parameter packs expanded by the function parameter pack. If
-deduction succeeds for a given type, the type from the argument template
-is considered to be at least as specialized as the type from the
-parameter template.
 ``` cpp
 template<class... Args>           void f(Args... args);         // #1
 template<class T1, class... Args> void f(T1 a1, Args... args);  // #2
 template<class T1, class T2>      void f(T1 a1, T2 a2);         // #3
 f();                // calls #1
 f(1, 2, 3);         // calls #2
-f(1, 2); // calls #3; non-variadic template #3 is more
- // specialized than the variadic templates #1 and #2
 ```
 If, for a given type, deduction succeeds in both directions (i.e., the
 types are identical after the transformations above) and both `P` and
 `A` were reference types (before being replaced with the type referred
 to above):
 - if the type from the argument template was an lvalue reference and the
-  type from the parameter template was not, the argument type is
-  considered to be more specialized than the other; otherwise,
 - if the type from the argument template is more cv-qualified than the
-  type from the parameter template (as described above), the argument
-  type is considered to be more specialized than the other; otherwise,
-- neither type is more specialized than the other.
-If for each type being considered a given template is at least as
-specialized for all types and more specialized for some set of types and
-the other template is not more specialized for any types or is not at
-least as specialized for any types, then the given template is more
-specialized than the other template. Otherwise, neither template is more
-specialized than the other.
 In most cases, all template parameters must have values in order for
 deduction to succeed, but for partial ordering purposes a template
 parameter may remain without a value provided it is not used in the
-types being used for partial ordering. A template parameter used in a
-non-deduced context is considered used.
 ``` cpp
 template <class T> T f(int);            // #1
 template <class T, class U> T f(U);     // #2
 void g() {
   f<int>(1);                            // calls #1
 }
 ```
-Partial ordering of function templates containing template parameter
-packs is independent of the number of deduced arguments for those
-template parameter packs.
 ``` cpp
 template<class ...> struct Tuple { };
 template<class ... Types> void g(Tuple<Types ...>);                 // #1
 template<class T1, class ... Types> void g(Tuple<T1, Types ...>);   // #2
@@ -588,10 +778,12 @@ g(Tuple<>());                   // calls #1
 g(Tuple<int, float>());         // calls #2
 g(Tuple<int, float&>());        // calls #3
 g(Tuple<int>());                // calls #3
 ```
 #### Deducing template arguments from a type <a id="temp.deduct.type">[[temp.deduct.type]]</a>
 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
@@ -606,11 +798,12 @@ In some cases, the deduction is done using a single set of types `P` and
 deduced template argument values are then combined. If type deduction
 cannot be done for any `P/A` pair, or if for any pair the deduction
 leads to more than one possible set of deduced values, or if different
 pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
-deduction fails.
 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
@@ -631,10 +824,15 @@ 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.
 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*.
@@ -652,35 +850,43 @@ The non-deduced contexts are:
   - no function matches the function parameter type, or
   - the set of functions 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
- `std::initializer_list` or reference to possibly cv-qualified
- `std::initializer_list` type.
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
 - A function parameter pack that does not occur at the end of the
   *parameter-declaration-list*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
-non-deduced types. If a type is specified as `A<T>::B<T2>`, both `T` and
 `T2` are non-deduced. Likewise, if a type is specified as
 `A<I+J>::X<T>`, `I`, `J`, and `T` are non-deduced. If a type is
 specified as `void` `f(typename` `A<T>::B,` `A<T>)`, the `T` in
-`A<T>::B` is non-deduced but the `T` in `A<T>` is deduced.
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
 ``` cpp
-template<class T> void f(T x, T y) { /* ... */ }
-struct A { /* ... */ };
-struct B : A { /* ... */ };
 void g(A a, B b) {
   f(a,b);           // error: T could be A or B
   f(b,a);           // error: T could be A or B
   f(a,a);           // OK: T is A
   f(b,b);           // OK: T is B
@@ -731,10 +937,12 @@ void t() {
   f(d);             // calls f(B<int>&)
   f(d2);            // calls f(B<int>&)
 }
 ```
 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
@@ -763,20 +971,20 @@ template-name<i>  (where template-name refers to a class template)
 TT<T>
 TT<i>
 TT<>
 ```
-where `(T)` represents a *parameter-type-list* where at least one
-parameter type contains a `T`, and `()` represents a
-*parameter-type-list* where no parameter type contains a `T`. 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 `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
@@ -788,10 +996,12 @@ 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.
 ``` cpp
 template<class T1, class... Z> class S;                               // #1
 template<class T1, class... Z> class S<T1, const Z&...> { };          // #2
 template<class T1, class T2>   class S<T1, const T2&> { };            // #3
 S<int, const int&> s;         // both #2 and #3 match; #3 is more specialized
@@ -800,24 +1010,30 @@ template<class T, class... U>            struct A { };                // #1
 template<class T1, class T2, class... U> struct A<T1, T2*, U...> { }; // #2
 template<class T1, class T2>             struct A<T1, T2> { };        // #3
 template struct A<int, int*>; // selects #2
 ```
 Similarly, if `P` has a form that contains `(T)`, then each parameter
-type `Pᵢ` of the respective *parameter-type-list* of `P` is compared
-with the corresponding parameter type `Aᵢ` of the corresponding
-*parameter-type-list* of `A`. If `P` and `A` are function types that
 originated from deduction when taking the address of a function
 template ([[temp.deduct.funcaddr]]) or when deducing template arguments
 from a function declaration ([[temp.deduct.decl]]) and `Pᵢ` and `Aᵢ`
-are parameters of the top-level *parameter-type-list* of `P` and `A`,
-respectively, `Pᵢ` is adjusted if it is an rvalue reference to a
-cv-unqualified template parameter and `Aᵢ` is an lvalue reference, in
-which case the type of `Pᵢ` is changed to be the template parameter type
-(i.e., `T&&` is changed to simply `T`). As a result, when `Pᵢ` is `T&&`
-and `Aᵢ` is `X&`, the adjusted `Pᵢ` will be `T`, causing `T` to be
-deduced as `X&`.
 ``` cpp
 template <class T> void f(T&&);
 template <> void f(int&) { }    // #1
 template <> void f(int&&) { }   // #2
@@ -825,32 +1041,40 @@ void g(int i) {
   f(i);                         // calls f<int&>(int&), i.e., #1
   f(0);                         // calls f<int>(int&&), i.e., #2
 }
 ```
 If the *parameter-declaration* corresponding to `Pᵢ` is a function
 parameter pack, then the type of its *declarator-id* is compared with
-each remaining parameter type in the *parameter-type-list* of `A`. Each
 comparison deduces template arguments for subsequent positions in the
 template parameter packs expanded by the function parameter pack. During
 partial ordering ([[temp.deduct.partial]]), if `Aᵢ` was originally a
 function parameter pack:
 - if `P` does not contain a function parameter type corresponding to
   `Aᵢ` then `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a function parameter pack, template argument
   deduction fails.
 ``` cpp
 template<class T, class... U> void f(T*, U...) { }  // #1
 template<class T>             void f(T) { }         // #2
 template void f(int*);                              // selects #1
 ```
 These forms can be used in the same way as `T` is for further
 composition of types.
 ``` cpp
 X<int> (*)(char[6])
 ```
 is of the form
@@ -865,22 +1089,67 @@ which is a variant of
 type (*)(T)
 ```
 where type is `X<int>` and `T` is `char[6]`.
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
-A template type argument cannot be deduced from the type of a non-type
-*template-argument*.
 ``` cpp
-template<class T, T i> void f(double a[10][i]);
-int v[10][20];
-f(v);               // error: argument for template-parameter T cannot be deduced
 ```
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
 template<int i> void f1(int a[10][i]);
@@ -895,17 +1164,23 @@ void g() {
   f2<10>(v);                    // OK
   f3(v);                        // OK: i deduced to be 10
 }
 ```
 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.
 ``` cpp
-template <int i> class A { /* ... */ };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 void k() {
   A<1> a1;
   A<2> a2;
@@ -913,10 +1188,16 @@ void k() {
   g<0>(a1);                     // OK
   f(a1, a2);                    // OK
 }
 ```
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 template<int i, typename T>
@@ -925,23 +1206,26 @@ T deduce(typename A<T>::X x,    // T is not deduced here
          typename B<i>::Y y);   // i is not deduced here
 A<int> a;
 B<77>  b;
 int    x = deduce<77>(a.xm, 62, b.ym);
-// T is deduced to be int, a.xm must be convertible to
-// A<int>::X
-// i is explicitly specified to be 77, b.ym must be convertible
-// to B<77>::Y
 ```
-If `P` has a form that contains `<i>`, and if the type of the
-corresponding value of `A` differs from the type of `i`, deduction
-fails. If `P` has a form that contains `[i]`, and if the type of `i` is
-not an integral type, deduction fails.[^8]
 ``` cpp
-template<int i> class A { /* ... */ };
 template<short s> void f(A<s>);
 void k1() {
   A<1> a;
   f(a);             // error: deduction fails for conversion from int to short
   f<1>(a);          // OK
@@ -953,13 +1237,17 @@ void k2() {
   B<1> b;
   g(b);             // OK: cv-qualifiers are ignored on template parameter types
 }
 ```
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer to member function type.
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void g(char,int);
@@ -971,37 +1259,49 @@ int m() {
   f(&h);            // OK: void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
   f(1);             // OK: call f<int>(1,7)
   f();              // error: cannot deduce T
   f<int>();         // OK: call f<int>(5,7)
 }
 ```
 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.
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 A<B> ab;
 f(ab);              // calls f(A<B>)
 ```
-Template argument deduction involving parameter packs (
 [[temp.variadic]]) can deduce zero or more arguments for each parameter
-pack.
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
@@ -1017,10 +1317,12 @@ Y<> y1;                         // use primary template; Types is empty
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```
 #### Deducing template arguments from a function declaration <a id="temp.deduct.decl">[[temp.deduct.decl]]</a>
 In a declaration whose *declarator-id* refers to a specialization of a
 function template, template argument deduction is performed to identify
 the specialization to which the declaration refers. Specifically, this

 When a function template specialization is referenced, all of the
 template arguments shall have values. The values can be explicitly
 specified or, in some cases, be deduced from the use or obtained from
 default *template-argument*s.
+[*Example 1*:
 ``` cpp
 void f(Array<dcomplex>& cv, Array<int>& ci) {
   sort(cv);                     // calls sort(Array<dcomplex>&)
   sort(ci);                     // calls sort(Array<int>&)
 }
   int i = convert<int>(d);      // calls convert<int,double>(double)
   int c = convert<char>(d);     // calls convert<char,double>(double)
 }
 ```
+— *end example*]
 When an explicit template argument list is specified, the template
 arguments must be compatible with the template parameter list and must
 result in a valid function type as described below; otherwise type
 deduction fails. Specifically, the following steps are performed when
 evaluating an explicitly specified template argument list with respect
   [[temp.arg.nontype]], otherwise type deduction fails.
 - 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
+“`void(*)(int,int*)`”. — *end example*]
+[*Note 1*: A top-level qualifier in a function parameter declaration
+does not affect the function type but still affects the type of the
+function parameter variable within the function. — *end note*]
+[*Example 3*:
 ``` cpp
 template <class T> void f(T t);
 template <class X> void g(const X x);
 template <class Z> void h(Z, Z*);
   // #5: function type is h(int, const int*)
   h<const int>(1,0);
 }
 ```
+— *end example*]
+[*Note 2*: `f<int>(1)` and `f<const int>(1)` call distinct functions
+even though both of the functions called have the same function
+type. — *end note*]
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
 argument has not been deduced and its corresponding template parameter
 has a default argument, the template argument is determined by
 substituting the template arguments determined for preceding template
 parameters into the default argument. If the substitution results in an
 invalid type, as described above, type deduction fails.
+[*Example 4*:
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
 void g() {
   f<int>();         // f<int,double>(0,0)
   f<int,char>();    // f<int,char>(0,0)
 }
 ```
+— *end example*]
 When all template arguments have been deduced or obtained from default
 template arguments, all uses of template parameters in the template
 parameter list of the template and the function type are replaced with
 the corresponding deduced or default argument values. If the
 substitution results in an invalid type, as described above, type
 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.
+[*Note 3*: 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 5*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
 template <class T> typename T::X f(typename A<T>::X);
 template <class T> void f(...) { }
   f<int>(0);        // OK, substituting return type causes deduction to fail
   g<int>(0);        // error, substituting parameter type instantiates A<int>
 }
 ```
+— *end example*]
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
 ill-formed, with a diagnostic required, if written using the substituted
+arguments.
+[*Note 4*: If no diagnostic is required, the program is still
+ill-formed. Access checking is done as part of the substitution
+process. — *end note*]
 Only invalid types and expressions in the immediate context of the
 function type and its template parameter types can result in a deduction
+failure.
+[*Note 5*: The substitution into types and expressions can result in
+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*]
+[*Example 6*:
 ``` cpp
 struct X { };
 struct Y {
   Y(X){}
 X x1, x2;
 X x3 = f(x1, x2);   // deduction fails on #1 (cannot add X+X), calls #2
 ```
+— *end example*]
+[*Note 6*:
 Type deduction may fail for the following reasons:
 - Attempting to instantiate a pack expansion containing multiple
   parameter packs of differing lengths.
 - Attempting to create an array with an element type that is `void`, a
   function type, a reference type, or an abstract class type, or
   attempting to create an array with a size that is zero or negative.
+  \[*Example 7*:
   ``` cpp
   template <class T> int f(T[5]);
   int I = f<int>(0);
   int j = f<void>(0);             // invalid array
   ```
+  — *end example*]
 - Attempting to use a type that is not a class or enumeration type in a
   qualified name.
+  \[*Example 8*:
   ``` cpp
   template <class T> int f(typename T::B*);
   int i = f<int>(0);
   ```
+  — *end example*]
 - Attempting to use a type in a *nested-name-specifier* of a
   *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 9*:
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
   template <class T> void f(typename T::Y*){}
   template <class T> void g(X<T::N>*){}
     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*]
 - Attempting to create a pointer to reference type.
 - Attempting to create a reference to `void`.
 - Attempting to create “pointer to member of `T`” when `T` is not a
   class type.
+  \[*Example 10*:
   ``` cpp
   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 11*:
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T()>*);
   struct X {};
   int i0 = f<X>(0);
   ```
+  — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
   declaration.
+  \[*Example 12*:
   ``` cpp
   template <class T, T*> int f(int);
   int i2 = f<int,1>(0);           // can't conv 1 to int*
   ```
+  — *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 create a function type in which a parameter type or the
   return type is an abstract class type ([[class.abstract]]).
+— *end note*]
+[*Example 13*:
+In the following example, assuming a `signed char` cannot represent the
+value 1000, a narrowing conversion ([[dcl.init.list]]) would be
+required to convert the *template-argument* of type `int` to
+`signed char`, therefore substitution fails for the second template (
+[[temp.arg.nontype]]).
 ``` cpp
 template <int> int f(int);
 template <signed char> int f(int);
+int i1 = f<1000>(0); // OK
+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'>` 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,
+taking `P'` as a function template parameter type and the initializer
+element as its argument, and 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>);
 f({1,2,3});                     // T deduced to int
 f({1,"asdf"});                  // error: T deduced to both int and const char*
 template<class T> void g(T);
 g({1,2,3});                     // error: no argument deduced for T
+template<class T, int N> void h(T const(&)[N]);
+h({1,2,3});                     // T deduced to int, N deduced to 3
+template<class T> void j(T const(&)[3]);
+j({42});                        // T deduced to int, array bound not considered
+struct Aggr { int i; int j; };
+template<int N> void k(Aggr const(&)[N]);
+k({1,2,3});                     // error: deduction fails, no conversion from int to Aggr
+k({{1},{2},{3}});               // OK, N deduced to 3
+template<int M, int N> void m(int const(&)[M][N]);
+m({{1,2},{3,4}});               // M and N both deduced to 2
+template<class T, int N> void n(T const(&)[N], T);
+n({{1},{2},{3}},Aggr());        // OK, T is Aggr, N is 3
 ```
+— *end example*]
 For a function parameter pack that occurs at the end of the
+*parameter-declaration-list*, deduction is performed for each remaining
+argument of the call, taking the type `P` of the *declarator-id* of the
+function parameter pack as the corresponding function template parameter
+type. 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 (
+[[temp.deduct.type]]), the type of that parameter pack is never deduced.
+[*Example 2*:
 ``` cpp
 template<class ... Types> void f(Types& ...);
 template<class T1, class ... Types> void g(T1, Types ...);
 template<class T1, class ... Types> void g1(Types ..., T1);
   const int z = x;
   f(x, y, z);                   // Types is deduced to int, float, const int
   g(x, y, z);                   // T1 is deduced to int; Types is deduced to float, int
   g1(x, y, z);                  // error: Types is not deduced
   g1<int, int, int>(x, y, z);   // OK, no deduction occurs
 }
 ```
+— *end example*]
 If `P` is not a reference type:
 - If `A` is an array type, the pointer type produced by the
   array-to-pointer standard conversion ([[conv.array]]) is used in
   place of `A` for type deduction; otherwise,
 - If `A` is a function type, the pointer type produced by the
   function-to-pointer standard conversion ([[conv.func]]) is used in
   place of `A` for type deduction; otherwise,
+- If `A` is a cv-qualified type, the top-level cv-qualifiers of `A`’s
   type are ignored for type deduction.
+If `P` is a cv-qualified type, the top-level cv-qualifiers of `P`’s type
 are ignored for type deduction. If `P` is a reference type, the type
+referred to by `P` is used for type deduction.
+[*Example 3*:
+``` cpp
+template<class T> int f(const T&);
+int n1 = f(5);                  // calls f<int>(const int&)
+const int i = 0;
+int n2 = f(i);                  // calls f<int>(const int&)
+template <class T> int g(volatile T&);
+int n3 = g(i);                  // calls g<const int>(const volatile int&)
+```
+— *end example*]
+A *forwarding reference* is an rvalue reference to a cv-unqualified
+template parameter that does not represent a template parameter of a
+class template (during class template argument deduction (
+[[over.match.class.deduct]])). If `P` is a forwarding reference and the
+argument is an lvalue, the type “lvalue reference to `A`” is used in
+place of `A` for type deduction.
+[*Example 4*:
 ``` cpp
+template <class T> int f(T&& heisenreference);
 template <class T> int g(const T&&);
 int i;
 int n1 = f(i);                  // calls f<int&>(int&)
 int n2 = f(0);                  // calls f<int>(int&&)
 int n3 = g(i);                  // error: would call g<int>(const int&&), which
                                 // would bind an rvalue reference to an lvalue
+template <class T> struct A {
+  template <class U>
+    A(T&&, U&&, int*);          // #1: T&& is not a forwarding reference.
+                                // U&& is a forwarding reference.
+  A(T&&, int*);                 // #2
+};
+template <class T> A(T&&, int*) -> A<T>;    // #3: T&& is a forwarding reference.
+int *ip;
+A a{i, 0, ip};                  // error: cannot deduce from #1
+A a0{0, 0, ip};                 // uses #1 to deduce A<int> and #1 to initialize
+A a2{i, ip};                    // uses #3 to deduce A<int&> and #2 to initialize
 ```
+— *end example*]
 In general, the deduction process attempts to find template argument
 values that will make the deduced `A` identical to `A` (after the type
 `A` is transformed as described above). However, there are three cases
 that allow a difference:
 - If the original `P` is a reference type, the deduced `A` (i.e., the
   type referred to by the reference) can be more cv-qualified than the
   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 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 pointed to by the
   deduced `A`.
 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*]
+When `P` is a function type, function pointer type, or 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 5*:
 ``` cpp
+// Only one function of an overload set matches the call so the function parameter is a deduced context.
 template <class T> int f(T (*p)(T));
 int g(int);
 int g(char);
 int i = f(g);       // calls f(int (*)(int))
 ```
+— *end example*]
+[*Example 6*:
 ``` cpp
+// Ambiguous deduction causes the second function parameter to be a non-deduced context.
 template <class T> int f(T, T (*p)(T));
 int g(int);
 char g(char);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
+— *end example*]
+[*Example 7*:
 ``` cpp
+// The overload set contains a template, causing the second function parameter to be a non-deduced context.
 template <class T> int f(T, T (*p)(T));
 char g(char);
 template <class T> T g(T);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
+— *end example*]
+If deduction succeeds for all parameters that contain
+*template-parameter*s that participate in template argument deduction,
+and all template arguments are explicitly specified, deduced, or
+obtained from default template arguments, remaining parameters are then
+compared with the corresponding arguments. For each remaining parameter
+`P` with a type that was non-dependent before substitution of any
+explicitly-specified template arguments, if the corresponding argument
+`A` cannot be implicitly converted to `P`, deduction fails.
+[*Note 2*: Parameters with dependent types in which no
+*template-parameter*s participate in template argument deduction, and
+parameters that became non-dependent due to substitution of
+explicitly-specified template arguments, will be checked during overload
+resolution. — *end note*]
+[*Example 8*:
+``` cpp
+  template <class T> struct Z {
+    typedef typename T::x xx;
+  };
+  template <class T> typename Z<T>::xx f(void *, T);    // #1
+  template <class T> void f(int, T);                    // #2
+  struct A {} a;
+  int main() {
+    f(1, a);        // OK, deduction fails for #1 because there is no conversion from int to void*
+  }
+```
+— *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 overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
   array-to-pointer standard conversion ([[conv.array]]) is used in
   place of `P` for type deduction; otherwise,
 - If `P` is a function type, the pointer type produced by the
   function-to-pointer standard conversion ([[conv.func]]) is used in
   place of `P` for type deduction; otherwise,
+- If `P` is a cv-qualified type, the top-level cv-qualifiers of `P`’s
   type are ignored for type deduction.
+If `A` is a cv-qualified type, the top-level cv-qualifiers of `A`’s type
 are ignored for type deduction. If `A` is a reference type, the type
 referred to by `A` is used for type deduction.
 In general, the deduction process attempts to find template argument
 values that will make the deduced `A` identical to `A`. However, there
+are four cases that allow a difference:
 - If the original `A` is a reference type, `A` can be more cv-qualified
   than the deduced `A` (i.e., the type referred to by the reference)
+- If the original `A` is a function pointer type, `A` can be “pointer to
+  function” even if the deduced `A` is “pointer to noexcept function”.
+- If the original `A` is a pointer to member function type, `A` can be
+  “pointer to member of type function” even if the deduced `A` is
+  “pointer to member of type noexcept function”.
 - The deduced `A` can be another pointer or pointer to member type that
   can be converted to `A` via a qualification conversion.
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 If `A` is a type
 and `P` is a type
+then the cv-unqualified `T1` and `T2` are used as the types of `A` and
+`P` respectively for type deduction.
+[*Example 1*:
 ``` cpp
 struct A {
   template <class T> operator T***();
 };
 A a;
 const int * const * const * p1 = a;     // T is deduced as int, not const int
 ```
+— *end example*]
 #### Deducing template arguments during partial ordering <a id="temp.deduct.partial">[[temp.deduct.partial]]</a>
 Template argument deduction is done by comparing certain types
 associated with the two function templates being compared.
 Two sets of types are used to determine the partial ordering. For each
 of the templates involved there is the original function type and the
+transformed function type.
+[*Note 1*: The creation of the transformed type is described in
+[[temp.func.order]]. — *end note*]
+The deduction process uses the transformed type as the argument template
+and the original type of the other template as the parameter template.
+This process is done twice for each type involved in the partial
+ordering comparison: once using the transformed template-1 as the
+argument template and template-2 as the parameter template and again
+using the transformed template-2 as the argument template and template-1
+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
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
 corresponding type from the argument template are used as the types of
+`P` and `A`. If a particular `P` contains no *template-parameter*s that
+participate in template argument deduction, that `P` is not used to
+determine the ordering.
 Before the partial ordering is done, certain transformations are
 performed on the types used for partial ordering:
 - If `P` is a reference type, `P` is replaced by the type referred to.
 - If `P` is a cv-qualified type, `P` is replaced by the cv-unqualified
   version of `P`.
 - If `A` is a cv-qualified type, `A` is replaced by the cv-unqualified
   version of `A`.
+Using the resulting types `P` and `A`, the deduction is then done as
+described in  [[temp.deduct.type]]. If `P` is a function parameter pack,
+the type `A` of each remaining parameter type of the argument template
+is compared with the type `P` of the *declarator-id* of the function
+parameter pack. Each comparison deduces template arguments for
+subsequent positions in the template parameter packs expanded by the
+function parameter pack. Similarly, if `A` was transformed from a
+function parameter pack, it is compared with each remaining parameter
+type of the parameter template. If deduction succeeds for a given type,
+the type from the argument template is considered to be at least as
+specialized as the type from the parameter template.
+[*Example 1*:
 ``` cpp
 template<class... Args>           void f(Args... args);         // #1
 template<class T1, class... Args> void f(T1 a1, Args... args);  // #2
 template<class T1, class T2>      void f(T1 a1, T2 a2);         // #3
 f();                // calls #1
 f(1, 2, 3);         // calls #2
+f(1, 2); // calls #3; non-variadic template #3 is more specialized
+ // than the variadic templates #1 and #2
 ```
+— *end example*]
 If, for a given type, deduction succeeds in both directions (i.e., the
 types are identical after the transformations above) and both `P` and
 `A` were reference types (before being replaced with the type referred
 to above):
 - if the type from the argument template was an lvalue reference and the
+  type from the parameter template was not, the parameter type is not
+  considered to be at least as specialized as the argument type;
+  otherwise,
 - if the type from the argument template is more cv-qualified than the
+  type from the parameter template (as described above), the parameter
+  type is not considered to be at least as specialized as the argument
+ type.
+Function template `F` is *at least as specialized as* function template
+`G` if, for each pair of types used to determine the ordering, the type
+from `F` is at least as specialized as the type from `G`. `F` is *more
+specialized than* `G` if `F` is at least as specialized as `G` and `G`
+is not at least as specialized as `F`.
+If, after considering the above, function template `F` is at least as
+specialized as function template `G` and vice-versa, and if `G` has a
+trailing parameter pack for which `F` does not have a corresponding
+parameter, and if `F` does not have a trailing parameter pack, then `F`
+is more specialized than `G`.
 In most cases, all template parameters must have values in order for
 deduction to succeed, but for partial ordering purposes a template
 parameter may remain without a value provided it is not used in the
+types being used for partial ordering.
+[*Note 2*: A template parameter used in a non-deduced context is
+considered used. — *end note*]
+[*Example 2*:
 ``` cpp
 template <class T> T f(int);            // #1
 template <class T, class U> T f(U);     // #2
 void g() {
   f<int>(1);                            // calls #1
 }
 ```
+— *end example*]
+[*Note 3*: Partial ordering of function templates containing template
+parameter packs is independent of the number of deduced arguments for
+those template parameter packs. — *end note*]
+[*Example 3*:
 ``` cpp
 template<class ...> struct Tuple { };
 template<class ... Types> void g(Tuple<Types ...>);                 // #1
 template<class T1, class ... Types> void g(Tuple<T1, Types ...>);   // #2
 g(Tuple<int, float>());         // calls #2
 g(Tuple<int, float&>());        // calls #3
 g(Tuple<int>());                // calls #3
 ```
+— *end example*]
 #### Deducing template arguments from a type <a id="temp.deduct.type">[[temp.deduct.type]]</a>
 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
 deduced template argument values are then combined. If type deduction
 cannot be done for any `P/A` pair, or if for any pair the deduction
 leads to more than one possible set of deduced values, or if different
 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
 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]] and [[temp.deduct.partial]], 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*.
   - no function matches the function parameter type, or
   - the set of functions 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 (
+ [[temp.deduct.call]]).
+  \[*Example 1*:
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
+  — *end example*]
 - A function parameter pack that does not occur at the end of the
   *parameter-declaration-list*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
+non-deduced types.
+[*Example 2*: If a type is specified as `A<T>::B<T2>`, both `T` and
 `T2` are non-deduced. Likewise, if a type is specified as
 `A<I+J>::X<T>`, `I`, `J`, and `T` are non-deduced. If a type is
 specified as `void` `f(typename` `A<T>::B,` `A<T>)`, the `T` in
+`A<T>::B` is non-deduced but the `T` in `A<T>` is
+deduced. — *end example*]
+[*Example 3*:
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
 ``` cpp
+template<class T> void f(T x, T y) { ... }
+struct A { ... };
+struct B : A { ... };
 void g(A a, B b) {
   f(a,b);           // error: T could be A or B
   f(b,a);           // error: T could be A or B
   f(a,a);           // OK: T is A
   f(b,b);           // OK: T is B
   f(d);             // calls f(B<int>&)
   f(d2);            // calls f(B<int>&)
 }
 ```
+— *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
 TT<T>
 TT<i>
 TT<>
 ```
+where `(T)` represents a parameter-type-list ([[dcl.fct]]) where at
+least one parameter type contains a `T`, and `()` represents a
+parameter-type-list where no parameter type contains a `T`. 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
 - 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.
+[*Example 4*:
 ``` cpp
 template<class T1, class... Z> class S;                               // #1
 template<class T1, class... Z> class S<T1, const Z&...> { };          // #2
 template<class T1, class T2>   class S<T1, const T2&> { };            // #3
 S<int, const int&> s;         // both #2 and #3 match; #3 is more specialized
 template<class T1, class T2, class... U> struct A<T1, T2*, U...> { }; // #2
 template<class T1, class T2>             struct A<T1, T2> { };        // #3
 template struct A<int, int*>; // selects #2
 ```
+— *end example*]
 Similarly, if `P` has a form that contains `(T)`, then each parameter
+type `Pᵢ` of the respective parameter-type-list ([[dcl.fct]]) of `P` is
+compared with the corresponding parameter type `Aᵢ` of the corresponding
+parameter-type-list of `A`. If `P` and `A` are function types that
 originated from deduction when taking the address of a function
 template ([[temp.deduct.funcaddr]]) or when deducing template arguments
 from a function declaration ([[temp.deduct.decl]]) and `Pᵢ` and `Aᵢ`
+are parameters of the top-level parameter-type-list of `P` and `A`,
+respectively, `Pᵢ` is adjusted if it is a forwarding reference (
+[[temp.deduct.call]]) and `Aᵢ` is an lvalue reference, in which case the
+type of `Pᵢ` is changed to be the template parameter type (i.e., `T&&`
+is changed to simply `T`).
+[*Note 2*: As a result, when `Pᵢ` is `T&&` and `Aᵢ` is `X&`, the
+adjusted `Pᵢ` will be `T`, causing `T` to be deduced as
+`X&`. — *end note*]
+[*Example 5*:
 ``` cpp
 template <class T> void f(T&&);
 template <> void f(int&) { }    // #1
 template <> void f(int&&) { }   // #2
   f(i);                         // calls f<int&>(int&), i.e., #1
   f(0);                         // calls f<int>(int&&), i.e., #2
 }
 ```
+— *end example*]
 If the *parameter-declaration* corresponding to `Pᵢ` is a function
 parameter pack, then the type of its *declarator-id* is compared with
+each remaining parameter type in the parameter-type-list of `A`. Each
 comparison deduces template arguments for subsequent positions in the
 template parameter packs expanded by the function parameter pack. During
 partial ordering ([[temp.deduct.partial]]), if `Aᵢ` was originally a
 function parameter pack:
 - if `P` does not contain a function parameter type corresponding to
   `Aᵢ` then `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a function parameter pack, template argument
   deduction fails.
+[*Example 6*:
 ``` cpp
 template<class T, class... U> void f(T*, U...) { }  // #1
 template<class T>             void f(T) { }         // #2
 template void f(int*);                              // selects #1
 ```
+— *end example*]
 These forms can be used in the same way as `T` is for further
 composition of types.
+[*Example 7*:
 ``` cpp
 X<int> (*)(char[6])
 ```
 is of the form
 type (*)(T)
 ```
 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*:
 ``` cpp
+template<long n> struct A { };
+template<typename T> struct C;
+template<typename T, T n> struct C<A<n>> {
+  using Q = T;
+};
+using R = long;
+using R = C<A<2>>::Q;           // OK; T was deduced to long from the
+                                // template argument value in the type A<2>
 ```
+— *end example*]
+The type of `N` in the type `T[N]` is `std::size_t`.
+[*Example 9*:
+``` cpp
+template<typename T> struct S;
+template<typename T, T n> struct S<int[n]> {
+  using Q = T;
+};
+using V = decltype(sizeof 0);
+using V = S<int[42]>::Q;        // OK; T was deduced to std::size_t from the type int[42]
+```
+— *end example*]
+[*Example 10*:
+``` cpp
+template<class T, T i> void f(int (&a)[i]);
+int v[10];
+void g() {
+  f(v);                         // OK: T is std::size_t
+}
+```
+— *end example*]
+[*Note 3*:
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
 template<int i> void f1(int a[10][i]);
   f2<10>(v);                    // OK
   f3(v);                        // OK: i deduced to be 10
 }
 ```
+— *end note*]
+[*Note 4*:
 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 11*:
 ``` cpp
+template <int i> class A { ... };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 void k() {
   A<1> a1;
   A<2> a2;
   g<0>(a1);                     // OK
   f(a1, a2);                    // OK
 }
 ```
+— *end example*]
+— *end note*]
+[*Note 5*:
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 template<int i, typename T>
          typename B<i>::Y y);   // i is not deduced here
 A<int> a;
 B<77>  b;
 int    x = deduce<77>(a.xm, 62, b.ym);
+// T is deduced to be int, a.xm must be convertible to A<int>::X
+// i is explicitly specified to be 77, b.ym must be convertible to B<77>::Y
 ```
+— *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.[^8]
+[*Example 12*:
 ``` cpp
+template<int i> class A { ... };
 template<short s> void f(A<s>);
 void k1() {
   A<1> a;
   f(a);             // error: deduction fails for conversion from int to short
   f<1>(a);          // OK
   B<1> b;
   g(b);             // OK: cv-qualifiers are ignored on template parameter types
 }
 ```
+— *end example*]
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer to member function type.
+[*Example 13*:
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void g(char,int);
   f(&h);            // OK: void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
+— *end example*]
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
+[*Example 14*:
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
   f(1);             // OK: call f<int>(1,7)
   f();              // error: cannot deduce T
   f<int>();         // OK: call f<int>(5,7)
 }
 ```
+— *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 15*:
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 A<B> ab;
 f(ab);              // calls f(A<B>)
 ```
+— *end example*]
+[*Note 6*: Template argument deduction involving parameter packs (
 [[temp.variadic]]) can deduce zero or more arguments for each parameter
+pack. — *end note*]
+[*Example 16*:
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```
+— *end example*]
 #### Deducing template arguments from a function declaration <a id="temp.deduct.decl">[[temp.deduct.decl]]</a>
 In a declaration whose *declarator-id* refers to a specialization of a
 function template, template argument deduction is performed to identify
 the specialization to which the declaration refers. Specifically, this

Diff to HTML by rtfpessoa