[temp.fct.spec] - C++17 → C++20

Files changed (1) hide show

tmp/tmpnun4yio0/{from.md → to.md} +475 -258

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

@@ -30,13 +30,14 @@ Here `f<int>(int*)` has a static variable `s` of type `int` and
 — *end example*]
 ### Explicit template argument specification <a id="temp.arg.explicit">[[temp.arg.explicit]]</a>
 Template arguments can be specified when referring to a function
-template specialization by qualifying the function template name with
-the list of *template-argument*s in the same way as *template-argument*s
-are specified in uses of a class template specialization.
 [*Example 1*:
 ``` cpp
 template<class T> void sort(Array<T>& v);
@@ -57,24 +58,28 @@ void g(double d) {
 }
 ```
 — *end example*]
 A template argument list may be specified when referring to a
 specialization of a function template
 - when a function is called,
 - when the address of a function is taken, when a function initializes a
   reference to function, or when a pointer to member function is formed,
 - in an explicit specialization,
 - in an explicit instantiation, or
 - in a friend declaration.
-Trailing template arguments that can be deduced ([[temp.deduct]]) or
 obtained from default *template-argument*s may be omitted from the list
-of explicit *template-argument*s. A trailing template parameter pack (
-[[temp.variadic]]) not otherwise deduced will be deduced to an empty
 sequence of template arguments. If all of the template arguments can be
 deduced, they may all be omitted; in this case, the empty template
 argument list `<>` itself may also be omitted. In contexts where
 deduction is done and fails, or in contexts where deduction is not done,
 if a template argument list is specified and it, along with any default
@@ -86,27 +91,27 @@ template specialization.
 ``` cpp
 template<class X, class Y> X f(Y);
 template<class X, class Y, class ... Z> X g(Y);
 void h() {
-  int i = f<int>(5.6);          // Y is deduced to be double
-  int j = f(5.6);               // ill-formed: X cannot be deduced
-  f<void>(f<int, bool>);        // Y for outer f deduced to be int (*)(bool)
-  f<void>(f<int>);              // ill-formed: f<int> does not denote a single function template specialization
-  int k = g<int>(5.6);          // Y is deduced to be double, Z is deduced to an empty sequence
-  f<void>(g<int, bool>);        // Y for outer f is deduced to be int (*)(bool),
-                                // Z is deduced to an empty sequence
 }
 ```
 — *end example*]
 [*Note 1*:
 An empty template argument list can be used to indicate that a given use
 refers to a specialization of a function template even when a
-non-template function ([[dcl.fct]]) is visible that would otherwise be
 used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
@@ -127,23 +132,23 @@ there are corresponding *template-parameter*s unless one of the
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
 template<class ... Args> void f2();
 void g() {
   f<int,const char*,double>("aa",3.0);
-  f<int,const char*>("aa",3.0); // Z is deduced to be double
-  f<int>("aa",3.0);             // Y is deduced to be const char*, and Z is deduced to be double
   f("aa",3.0);                  // error: X cannot be deduced
   f2<char, short, int, long>(); // OK
 }
 ```
 — *end example*]
-Implicit conversions (Clause  [[conv]]) will be performed on a function
-argument to convert it to the type of the corresponding function
-parameter if the parameter type contains no *template-parameter*s that
-participate in template argument deduction.
 [*Note 2*:
 Template parameters do not participate in template argument deduction if
 they are explicitly specified. For example,
@@ -161,63 +166,26 @@ void g() {
 ```
 — *end note*]
 [*Note 3*: Because the explicit template argument list follows the
-function template name, and because conversion member function templates
-and constructor member function templates are called without using a
-function name, there is no way to provide an explicit template argument
-list for these function templates. — *end note*]
-[*Note 4*:
-For simple function names, argument dependent lookup (
-[[basic.lookup.argdep]]) applies even when the function name is not
-visible within the scope of the call. This is because the call still has
-the syntactic form of a function call ([[basic.lookup.unqual]]). But
-when a function template with explicit template arguments is used, the
-call does not have the correct syntactic form unless there is a function
-template with that name visible at the point of the call. If no such
-name is visible, the call is not syntactically well-formed and
-argument-dependent lookup does not apply. If some such name is visible,
-argument dependent lookup applies and additional function templates may
-be found in other namespaces.
-[*Example 4*:
-``` cpp
-namespace A {
-  struct B { };
-  template<int X> void f(B);
-}
-namespace C {
-  template<class T> void f(T t);
-}
-void g(A::B b) {
-  f<3>(b);          // ill-formed: not a function call
-  A::f<3>(b);       // well-formed
-  C::f<3>(b);       // ill-formed; argument dependent lookup applies only to unqualified names
-  using C::f;
-  f<3>(b);          // well-formed because C::f is visible; then A::f is found by argument dependent lookup
-}
-```
-— *end example*]
-— *end note*]
 Template argument deduction can extend the sequence of template
 arguments corresponding to a template parameter pack, even when the
 sequence contains explicitly specified template arguments.
-[*Example 5*:
 ``` cpp
 template<class ... Types> void f(Types ... values);
 void g() {
-  f<int*, float*>(0, 0, 0);     // Types is deduced to the sequence int*, float*, int
 }
 ```
 — *end example*]
@@ -246,28 +214,14 @@ void g(double d) {
 }
 ```
 — *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
-to a given function template:
-- The specified template arguments must match the template parameters in
-  kind (i.e., type, non-type, template). There must not be more
-  arguments than there are parameters unless at least one parameter is a
-  template parameter pack, and there shall be an argument for each
-  non-pack parameter. Otherwise, type deduction fails.
-- Non-type arguments must match the types of the corresponding non-type
-  template parameters, or must be convertible to the types of the
-  corresponding non-type parameters as specified in
-  [[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
@@ -336,10 +290,13 @@ void g() {
 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
 deduction fails.
 At certain points in the template argument deduction process it is
 necessary to take a function type that makes use of template parameters
 and replace those template parameters with the corresponding template
@@ -354,11 +311,14 @@ 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.
 [*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*]
@@ -369,14 +329,18 @@ or expression. — *end note*]
 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(...) { }
 template <class T> auto g(typename A<T>::X) -> typename T::X;
 template <class T> void g(...) { }
-void h() {
   f<int>(0);        // OK, substituting return type causes deduction to fail
   g<int>(0);        // error, substituting parameter type instantiates A<int>
 }
 ```
 — *end example*]
@@ -388,22 +352,64 @@ 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){}
 };
@@ -415,30 +421,30 @@ 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);
   ```
@@ -449,11 +455,11 @@ Type deduction may fail for the following reasons:
   - 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>*){}
@@ -479,19 +485,19 @@ Type deduction may fail for the following reasons:
   — *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);
@@ -499,32 +505,30 @@ Type deduction may fail for the following reasons:
   — *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
@@ -538,84 +542,93 @@ int i2 = f<1>(0);               // ambiguous; not narrowing
 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);
 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
 }
 ```
 — *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
@@ -634,12 +647,12 @@ 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*:
@@ -675,19 +688,38 @@ values that will make the deduced `A` identical to `A` (after the type
 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.
@@ -695,23 +727,23 @@ deduction fails.
 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);
@@ -719,11 +751,11 @@ 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);
@@ -731,11 +763,11 @@ 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);
@@ -758,11 +790,11 @@ explicitly-specified template arguments, if the corresponding argument
 *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;
 };
@@ -777,16 +809,17 @@ resolution. — *end note*]
 — *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
-`P` and `A`, and the deduction is done as described in
-[[temp.deduct.type]].
-A placeholder type ([[dcl.spec.auto]]) in the return type of a function
 template is a non-deduced context. If template argument deduction
 succeeds for such a function, the return type is determined from
 instantiation of the function body.
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
@@ -797,20 +830,20 @@ required as the result of the conversion (call it `A`; see
 [[dcl.init]], [[over.match.conv]], and [[over.match.ref]] for the
 determination of that type) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
-transformations of `P` in the remainder of this section.
 If `A` is not a reference type:
 - If `P` is an array type, the pointer type produced by the
-  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
@@ -819,46 +852,23 @@ 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
 deduction fails.
-When the deduction process requires a qualification conversion for a
-pointer or pointer to member type as described above, the following
-process is used to determine the deduced template argument values:
-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.
@@ -879,21 +889,19 @@ 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.[^7]
 - 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.
 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.
@@ -937,14 +945,13 @@ 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,
@@ -959,18 +966,18 @@ 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*:
@@ -1029,32 +1036,32 @@ 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
   and the return type.
-- 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 the value
-so determined must be 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]] 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*.
@@ -1062,23 +1069,21 @@ The non-deduced contexts are:
 - 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 argument deduction cannot be done
- because the associated function argument is a function, or a set of
-  overloaded functions ([[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 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
   ```
@@ -1168,11 +1173,11 @@ 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
 T
-cv-list T
 T*
 T&
 T&&
 T[integer-constant]
 template-name<T>  (where template-name refers to a class template)
@@ -1194,12 +1199,12 @@ template-name<i>  (where template-name refers to a class template)
 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`.
@@ -1211,12 +1216,12 @@ corresponding argument Aᵢ of the corresponding template argument list of
 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.
@@ -1236,19 +1241,19 @@ 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
@@ -1271,11 +1276,11 @@ void g(int i) {
 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
@@ -1333,11 +1338,11 @@ 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*]
@@ -1350,11 +1355,11 @@ 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*:
@@ -1379,15 +1384,15 @@ template<int i> void f1(int a[10][i]);
 template<int i> void f2(int a[i][20]);
 template<int i> void f3(int (&a)[i][20]);
 void g() {
   int v[10][20];
-  f1(v);                        // OK: i deduced to be 20
   f1<20>(v);                    // OK
   f2(v);                        // error: cannot deduce template-argument i
   f2<10>(v);                    // OK
-  f3(v);                        // OK: i deduced to be 10
 }
 ```
 — *end note*]
@@ -1429,21 +1434,21 @@ 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
 ```
 — *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 { ... };
@@ -1463,11 +1468,11 @@ void k2() {
 ```
 — *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));
@@ -1516,12 +1521,12 @@ 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
@@ -1547,49 +1552,47 @@ 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
-is done for explicit instantiations ([[temp.explicit]]), explicit
-specializations ([[temp.expl.spec]]), and certain friend declarations (
-[[temp.friend]]). This is also done to determine whether a deallocation
 function template specialization matches a placement `operator new` (
-[[basic.stc.dynamic.deallocation]],  [[expr.new]]). In all these cases,
 `P` is the type of the function template being considered as a potential
 match and `A` is either the function type from the declaration or the
 type of the deallocation function that would match the placement
 `operator new` as described in  [[expr.new]]. The deduction is done as
 described in  [[temp.deduct.type]].
 If, for the set of function templates so considered, there is either no
-match or more than one match after partial ordering has been
-considered ([[temp.func.order]]), deduction fails and, in the
-declaration cases, the program is ill-formed.
 ### Overload resolution <a id="temp.over">[[temp.over]]</a>
-A function template can be overloaded either by (non-template) functions
-of its name or by (other) function templates of the same name. When a
-call to that name is written (explicitly, or implicitly using the
-operator notation), template argument deduction ([[temp.deduct]]) and
-checking of any explicit template arguments ([[temp.arg]]) are
-performed for each function template to find the template argument
-values (if any) that can be used with that function template to
-instantiate a function template specialization that can be invoked with
-the call arguments. For each function template, if the argument
-deduction and checking succeeds, the *template-argument*s (deduced
-and/or explicit) are used to synthesize the declaration of a single
-function template specialization which is added to the candidate
 functions set to be used in overload resolution. If, for a given
 function template, argument deduction fails or the synthesized function
 template specialization would be ill-formed, no such function is added
 to the set of candidate functions for that template. The complete set of
 candidate functions includes all the synthesized declarations and all of
 the non-template overloaded functions of the same name. The synthesized
 declarations are treated like any other functions in the remainder of
 overload resolution, except as explicitly noted in
-[[over.match.best]].[^9]
 [*Example 1*:
 ``` cpp
 template<class T> T max(T a, T b) { return a>b?a:b; }
@@ -1671,5 +1674,219 @@ and not defined at the point of the call. The program will be ill-formed
 unless a specialization for `f<const char*>`, either implicitly or
 explicitly generated, is present in some translation unit.
 — *end example*]

 — *end example*]
 ### Explicit template argument specification <a id="temp.arg.explicit">[[temp.arg.explicit]]</a>
 Template arguments can be specified when referring to a function
+template specialization that is not a specialization of a constructor
+template by qualifying the function template name with the list of
+*template-argument*s in the same way as *template-argument*s are
+specified in uses of a class template specialization.
 [*Example 1*:
 ``` cpp
 template<class T> void sort(Array<T>& v);
 }
 ```
 — *end example*]
+Template arguments shall not be specified when referring to a
+specialization of a constructor template ([[class.ctor]],
+[[class.qual]]).
 A template argument list may be specified when referring to a
 specialization of a function template
 - when a function is called,
 - when the address of a function is taken, when a function initializes a
   reference to function, or when a pointer to member function is formed,
 - in an explicit specialization,
 - in an explicit instantiation, or
 - in a friend declaration.
+Trailing template arguments that can be deduced [[temp.deduct]] or
 obtained from default *template-argument*s may be omitted from the list
+of explicit *template-argument*s. A trailing template parameter pack
+[[temp.variadic]] not otherwise deduced will be deduced as an empty
 sequence of template arguments. If all of the template arguments can be
 deduced, they may all be omitted; in this case, the empty template
 argument list `<>` itself may also be omitted. In contexts where
 deduction is done and fails, or in contexts where deduction is not done,
 if a template argument list is specified and it, along with any default
 ``` cpp
 template<class X, class Y> X f(Y);
 template<class X, class Y, class ... Z> X g(Y);
 void h() {
+  int i = f<int>(5.6);          // Y deduced as double
+  int j = f(5.6);               // error: X cannot be deduced
+  f<void>(f<int, bool>);        // Y for outer f deduced as int (*)(bool)
+  f<void>(f<int>);              // error: f<int> does not denote a single function template specialization
+  int k = g<int>(5.6);          // Y deduced as double; Z deduced as an empty sequence
+  f<void>(g<int, bool>);        // Y for outer f deduced as int (*)(bool),
+                                // Z deduced as an empty sequence
 }
 ```
 — *end example*]
 [*Note 1*:
 An empty template argument list can be used to indicate that a given use
 refers to a specialization of a function template even when a
+non-template function [[dcl.fct]] is visible that would otherwise be
 used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
 template<class ... Args> void f2();
 void g() {
   f<int,const char*,double>("aa",3.0);
+  f<int,const char*>("aa",3.0); // Z deduced as double
+  f<int>("aa",3.0);             // Y deduced as const char*; Z deduced as double
   f("aa",3.0);                  // error: X cannot be deduced
   f2<char, short, int, long>(); // OK
 }
 ```
 — *end example*]
+Implicit conversions [[conv]] will be performed on a function argument
+to convert it to the type of the corresponding function parameter if the
+parameter type contains no *template-parameter*s that participate in
+template argument deduction.
 [*Note 2*:
 Template parameters do not participate in template argument deduction if
 they are explicitly specified. For example,
 ```
 — *end note*]
 [*Note 3*: Because the explicit template argument list follows the
+function template name, and because constructor templates [[class.ctor]]
+are named without using a function name [[class.qual]], there is no way
+to provide an explicit template argument list for these function
+templates. — *end note*]
 Template argument deduction can extend the sequence of template
 arguments corresponding to a template parameter pack, even when the
 sequence contains explicitly specified template arguments.
+[*Example 4*:
 ``` cpp
 template<class ... Types> void f(Types ... values);
 void g() {
+  f<int*, float*>(0, 0, 0);     // Types deduced as the sequence int*, float*, int
 }
 ```
 — *end example*]
 }
 ```
 — *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
 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
+deduction fails. If the function template has associated constraints
+[[temp.constr.decl]], those constraints are checked for satisfaction
+[[temp.constr.constr]]. If the constraints are not satisfied, type
 deduction fails.
 At certain points in the template argument deduction process it is
 necessary to take a function type that makes use of template parameters
 and replace those template parameters with the corresponding template
 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 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*]
 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(...) { }
 template <class T> auto g(typename A<T>::X) -> typename T::X;
 template <class T> void g(...) { }
+template <class T> typename T::X h(typename A<T>::X);
+template <class T> auto h(typename A<T>::X) -> typename T::X;   // redeclaration
+template <class T> void h(...) { }
+void x() {
   f<int>(0);        // OK, substituting return type causes deduction to fail
   g<int>(0);        // error, substituting parameter type instantiates A<int>
+  h<int>(0);        // ill-formed, no diagnostic required
 }
 ```
 — *end example*]
 [*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, its template parameter types, and its
+*explicit-specifier* 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*]
+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 6*:
+The intent is to avoid requiring implementations to deal with
+substitution failure involving arbitrary statements.
 [*Example 6*:
+``` cpp
+template <class T>
+  auto f(T) -> decltype([]() { T::invalid; } ());
+void f(...);
+f(0);               // error: invalid expression not part of the immediate context
+template <class T, std::size_t = sizeof([]() { T::invalid; })>
+  void g(T);
+void g(...);
+g(0);               // error: invalid expression not part of the immediate context
+template <class T>
+  auto h(T) -> decltype([x = T::invalid]() { });
+void h(...);
+h(0);               // error: invalid expression not part of the immediate context
+template <class T>
+  auto i(T) -> decltype([]() -> typename T::invalid { });
+void i(...);
+i(0);               // error: invalid expression not part of the immediate context
+template <class T>
+  auto j(T t) -> decltype([](auto x) -> decltype(x.invalid) { } (t));   // #1
+void j(...);                                                            // #2
+j(0);               // deduction fails on #1, calls #2
+```
+— *end example*]
+— *end note*]
+[*Example 7*:
 ``` cpp
 struct X { };
 struct Y {
   Y(X){}
 };
 X x3 = f(x1, x2);   // deduction fails on #1 (cannot add X+X), calls #2
 ```
 — *end example*]
+[*Note 7*:
 Type deduction may fail for the following reasons:
+- Attempting to instantiate a pack expansion containing multiple packs
+  of differing lengths.
 - Attempting to create an array with an element type that is `void`, a
+  function type, or a reference type, or attempting to create an array
+  with a size that is zero or negative.
+  \[*Example 8*:
   ``` 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 9*:
   ``` cpp
   template <class T> int f(typename T::B*);
   int i = f<int>(0);
   ```
   - 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 10*:
   ``` 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>*){}
   — *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 11*:
   ``` 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 12*:
   ``` 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 13*:
   ``` 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.
 — *end note*]
+[*Example 14*:
 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
 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>);
+f({1,2,3});                     // T deduced as int
+f({1,"asdf"});                  // error: T deduced as 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 as int; N deduced as 3
 template<class T> void j(T const(&)[3]);
+j({42});                        // T deduced as 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 as 3
 template<int M, int N> void m(int const(&)[M][N]);
+m({{1,2},{3,4}});               // M and N both deduced as 2
 template<class T, int N> void n(T const(&)[N], T);
 n({{1},{2},{3}},Aggr());        // OK, T is Aggr, N is 3
+template<typename T, int N> void o(T (* const (&)[N])(T)) { }
+int f1(int);
+int f4(int);
+char f4(char);
+o({ &f1, &f4 });                                // OK, T deduced as int from first element, nothing
+                                                // deduced from second element, N deduced as 2
+o({ &f1, static_cast<char(*)(char)>(&f4) });    // error: conflicting deductions for T
 ```
 — *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 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);
 void h(int x, float& y) {
   const int z = x;
+  f(x, y, z);                   // Types deduced as int, float, const int
+  g(x, y, z);                   // T1 deduced as int; Types deduced as 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
 — *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*:
 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 `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>
+    struct X<T, Ts...> : X<Ts...> {};
+  struct D : X<int> {};
+  template <typename... T>
+  int f(const X<T...>&);
+  int x = f(D());     // calls f<int>, not f<>
+                      // B is X<>, C is X<int>
+  ```
+  — *end example*]
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
 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 6*:
 ``` 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 i = f(g);       // calls f(int (*)(int))
 ```
 — *end example*]
+[*Example 7*:
 ``` 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);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
+[*Example 8*:
 ``` 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-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 9*:
 ``` cpp
 template <class T> struct Z {
   typedef typename T::x xx;
 };
 — *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]]. If there is a
+target, the function template’s function type and the target type are
+used as the types of `P` and `A`, and the deduction is done as described
+in  [[temp.deduct.type]]. Otherwise, deduction is performed with empty
+sets of types P and A.
+A placeholder type [[dcl.spec.auto]] in the return type of a function
 template is a non-deduced context. If template argument deduction
 succeeds for such a function, the return type is determined from
 instantiation of the function body.
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
 [[dcl.init]], [[over.match.conv]], and [[over.match.ref]] for the
 determination of that type) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
+transformations of `P` in the remainder of this subclause.
 If `A` is not a reference type:
 - If `P` is an array type, the pointer type produced by the
+  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
 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
 deduction fails.
 #### 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.
 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.
 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.
                     // than the variadic templates #1 and #2
 ```
 — *end example*]
+If, for a given type, 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,
 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 function parameter pack for which `F` does not have a
+corresponding parameter, and if `F` does not have a trailing function
+parameter pack, then `F` is more specialized than `G`.
+In most cases, deduction fails if not all template parameters have
+values, 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*:
 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
   and the return type.
+- 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*.
 - 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
+  [[temp.deduct.call]].
   \[*Example 1*:
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
 T
+cv T
 T*
 T&
 T&&
 T[integer-constant]
 template-name<T>  (where template-name refers to a class template)
 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`.
 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*]
 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
 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
 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 as long from the
                                 // template argument value in the type A<2>
 ```
 — *end example*]
 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 as std::size_t from the type int[42]
 ```
 — *end example*]
 [*Example 10*:
 template<int i> void f2(int a[i][20]);
 template<int i> void f3(int (&a)[i][20]);
 void g() {
   int v[10][20];
+  f1(v);                        // OK: i deduced as 20
   f1<20>(v);                    // OK
   f2(v);                        // error: cannot deduce template-argument i
   f2<10>(v);                    // OK
+  f3(v);                        // OK: i deduced as 10
 }
 ```
 — *end note*]
          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 deduced as 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.[^13]
 [*Example 12*:
 ``` cpp
 template<int i> class A { ... };
 ```
 — *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));
 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
 #### 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
+is done for explicit instantiations [[temp.explicit]], explicit
+specializations [[temp.expl.spec]], and certain friend declarations
+[[temp.friend]]. This is also done to determine whether a deallocation
 function template specialization matches a placement `operator new` (
+[[basic.stc.dynamic.deallocation]], [[expr.new]]). In all these cases,
 `P` is the type of the function template being considered as a potential
 match and `A` is either the function type from the declaration or the
 type of the deallocation function that would match the placement
 `operator new` as described in  [[expr.new]]. The deduction is done as
 described in  [[temp.deduct.type]].
 If, for the set of function templates so considered, there is either no
+match or more than one match after partial ordering has been considered
+[[temp.func.order]], deduction fails and, in the declaration cases, the
+program is ill-formed.
 ### Overload resolution <a id="temp.over">[[temp.over]]</a>
+When a call to the name of a function or function template is written
+(explicitly, or implicitly using the operator notation), template
+argument deduction [[temp.deduct]] and checking of any explicit template
+arguments [[temp.arg]] are performed for each function template to find
+the template argument values (if any) that can be used with that
+function template to instantiate a function template specialization that
+can be invoked with the call arguments. For each function template, if
+the argument deduction and checking succeeds, the *template-argument*s
+(deduced and/or explicit) are used to synthesize the declaration of a
+single function template specialization which is added to the candidate
 functions set to be used in overload resolution. If, for a given
 function template, argument deduction fails or the synthesized function
 template specialization would be ill-formed, no such function is added
 to the set of candidate functions for that template. The complete set of
 candidate functions includes all the synthesized declarations and all of
 the non-template overloaded functions of the same name. The synthesized
 declarations are treated like any other functions in the remainder of
 overload resolution, except as explicitly noted in
+[[over.match.best]].[^14]
 [*Example 1*:
 ``` cpp
 template<class T> T max(T a, T b) { return a>b?a:b; }
 unless a specialization for `f<const char*>`, either implicitly or
 explicitly generated, is present in some translation unit.
 — *end example*]
+<!-- Link reference definitions -->
+[basic.def]: basic.md#basic.def
+[basic.def.odr]: basic.md#basic.def.odr
+[basic.link]: basic.md#basic.link
+[basic.lookup]: basic.md#basic.lookup
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.lookup.classref]: basic.md#basic.lookup.classref
+[basic.lookup.qual]: basic.md#basic.lookup.qual
+[basic.lookup.unqual]: basic.md#basic.lookup.unqual
+[basic.scope]: basic.md#basic.scope
+[basic.scope.hiding]: basic.md#basic.scope.hiding
+[basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[basic.types]: basic.md#basic.types
+[class.access]: class.md#class.access
+[class.base.init]: class.md#class.base.init
+[class.conv.fct]: class.md#class.conv.fct
+[class.ctor]: class.md#class.ctor
+[class.default.ctor]: class.md#class.default.ctor
+[class.derived]: class.md#class.derived
+[class.dtor]: class.md#class.dtor
+[class.friend]: class.md#class.friend
+[class.local]: class.md#class.local
+[class.mem]: class.md#class.mem
+[class.member.lookup]: class.md#class.member.lookup
+[class.pre]: class.md#class.pre
+[class.qual]: basic.md#class.qual
+[class.temporary]: basic.md#class.temporary
+[conv]: expr.md#conv
+[conv.array]: expr.md#conv.array
+[conv.fctptr]: expr.md#conv.fctptr
+[conv.func]: expr.md#conv.func
+[conv.lval]: expr.md#conv.lval
+[conv.qual]: expr.md#conv.qual
+[dcl.align]: dcl.md#dcl.align
+[dcl.attr.grammar]: dcl.md#dcl.attr.grammar
+[dcl.decl]: dcl.md#dcl.decl
+[dcl.enum]: dcl.md#dcl.enum
+[dcl.fct]: dcl.md#dcl.fct
+[dcl.fct.def.general]: dcl.md#dcl.fct.def.general
+[dcl.fct.default]: dcl.md#dcl.fct.default
+[dcl.init]: dcl.md#dcl.init
+[dcl.init.list]: dcl.md#dcl.init.list
+[dcl.meaning]: dcl.md#dcl.meaning
+[dcl.pre]: dcl.md#dcl.pre
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.stc]: dcl.md#dcl.stc
+[dcl.struct.bind]: dcl.md#dcl.struct.bind
+[dcl.type.class.deduct]: dcl.md#dcl.type.class.deduct
+[dcl.type.elab]: dcl.md#dcl.type.elab
+[dcl.type.simple]: dcl.md#dcl.type.simple
+[except.spec]: except.md#except.spec
+[expr.const]: expr.md#expr.const
+[expr.context]: expr.md#expr.context
+[expr.log.and]: expr.md#expr.log.and
+[expr.log.or]: expr.md#expr.log.or
+[expr.new]: expr.md#expr.new
+[expr.prim.fold]: expr.md#expr.prim.fold
+[expr.prim.id]: expr.md#expr.prim.id
+[expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
+[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
+[expr.ref]: expr.md#expr.ref
+[expr.sizeof]: expr.md#expr.sizeof
+[expr.typeid]: expr.md#expr.typeid
+[expr.unary.op]: expr.md#expr.unary.op
+[implimits]: limits.md#implimits
+[intro.defs]: intro.md#intro.defs
+[intro.object]: basic.md#intro.object
+[lex.string]: lex.md#lex.string
+[namespace.def]: dcl.md#namespace.def
+[namespace.memdef]: dcl.md#namespace.memdef
+[namespace.udecl]: dcl.md#namespace.udecl
+[over.ics.rank]: over.md#over.ics.rank
+[over.match]: over.md#over.match
+[over.match.best]: over.md#over.match.best
+[over.match.class.deduct]: over.md#over.match.class.deduct
+[over.match.conv]: over.md#over.match.conv
+[over.match.oper]: over.md#over.match.oper
+[over.match.ref]: over.md#over.match.ref
+[over.match.viable]: over.md#over.match.viable
+[over.over]: over.md#over.over
+[special]: class.md#special
+[stmt.if]: stmt.md#stmt.if
+[support.types]: support.md#support.types
+[temp]: #temp
+[temp.alias]: #temp.alias
+[temp.arg]: #temp.arg
+[temp.arg.explicit]: #temp.arg.explicit
+[temp.arg.nontype]: #temp.arg.nontype
+[temp.arg.template]: #temp.arg.template
+[temp.arg.type]: #temp.arg.type
+[temp.class]: #temp.class
+[temp.class.order]: #temp.class.order
+[temp.class.spec]: #temp.class.spec
+[temp.class.spec.match]: #temp.class.spec.match
+[temp.class.spec.mfunc]: #temp.class.spec.mfunc
+[temp.concept]: #temp.concept
+[temp.constr]: #temp.constr
+[temp.constr.atomic]: #temp.constr.atomic
+[temp.constr.constr]: #temp.constr.constr
+[temp.constr.decl]: #temp.constr.decl
+[temp.constr.normal]: #temp.constr.normal
+[temp.constr.op]: #temp.constr.op
+[temp.constr.order]: #temp.constr.order
+[temp.decls]: #temp.decls
+[temp.deduct]: #temp.deduct
+[temp.deduct.call]: #temp.deduct.call
+[temp.deduct.conv]: #temp.deduct.conv
+[temp.deduct.decl]: #temp.deduct.decl
+[temp.deduct.funcaddr]: #temp.deduct.funcaddr
+[temp.deduct.guide]: #temp.deduct.guide
+[temp.deduct.partial]: #temp.deduct.partial
+[temp.deduct.type]: #temp.deduct.type
+[temp.dep]: #temp.dep
+[temp.dep.candidate]: #temp.dep.candidate
+[temp.dep.constexpr]: #temp.dep.constexpr
+[temp.dep.expr]: #temp.dep.expr
+[temp.dep.res]: #temp.dep.res
+[temp.dep.temp]: #temp.dep.temp
+[temp.dep.type]: #temp.dep.type
+[temp.expl.spec]: #temp.expl.spec
+[temp.explicit]: #temp.explicit
+[temp.fct]: #temp.fct
+[temp.fct.spec]: #temp.fct.spec
+[temp.fold.empty]: #temp.fold.empty
+[temp.friend]: #temp.friend
+[temp.func.order]: #temp.func.order
+[temp.inject]: #temp.inject
+[temp.inst]: #temp.inst
+[temp.local]: #temp.local
+[temp.mem]: #temp.mem
+[temp.mem.class]: #temp.mem.class
+[temp.mem.enum]: #temp.mem.enum
+[temp.mem.func]: #temp.mem.func
+[temp.names]: #temp.names
+[temp.nondep]: #temp.nondep
+[temp.over]: #temp.over
+[temp.over.link]: #temp.over.link
+[temp.param]: #temp.param
+[temp.point]: #temp.point
+[temp.pre]: #temp.pre
+[temp.res]: #temp.res
+[temp.spec]: #temp.spec
+[temp.static]: #temp.static
+[temp.type]: #temp.type
+[temp.variadic]: #temp.variadic
+[^1]: Since template *template-parameter*s and template
+    *template-argument*s are treated as types for descriptive purposes,
+    the terms *non-type parameter* and *non-type argument* are used to
+    refer to non-type, non-template parameters and arguments.
+[^2]: A `>` that encloses the *type-id* of a `dynamic_cast`,
+    `static_cast`, `reinterpret_cast` or `const_cast`, or which encloses
+    the *template-argument*s of a subsequent *template-id*, is
+    considered nested for the purpose of this description.
+[^3]: There is no such ambiguity in a default *template-argument*
+    because the form of the *template-parameter* determines the
+    allowable forms of the *template-argument*.
+[^4]: A constraint is in disjunctive normal form when it is a
+    disjunction of clauses where each clause is a conjunction of atomic
+    constraints.
+    \[*Example 5*: For atomic constraints A, B, and C, the disjunctive
+    normal form of the constraint A ∧ (B ∨ C) is (A ∧ B) ∨ (A ∧ C). Its
+    disjunctive clauses are (A ∧ B) and (A ∧ C). — *end example*]
+[^5]: A constraint is in conjunctive normal form when it is a
+    conjunction of clauses where each clause is a disjunction of atomic
+    constraints.
+    \[*Example 6*: For atomic constraints A, B, and C, the constraint
+    A ∧ (B ∨ C) is in conjunctive normal form. Its conjunctive clauses
+    are A and (B ∨ C). — *end example*]
+[^6]: The identity of enumerators is not preserved.
+[^7]: An array as a *template-parameter* decays to a pointer.
+[^8]: There is no way in which they could be used.
+[^9]: That is, declarations of non-template functions do not merely
+    guide overload resolution of function template specializations with
+    the same name. If such a non-template function is odr-used
+    [[basic.def.odr]] in a program, it must be defined; it will not be
+    implicitly instantiated using the function template definition.
+[^10]: This includes friend function declarations.
+[^11]: Friend declarations do not introduce new names into any scope,
+    either when the template is declared or when it is instantiated.
+[^12]: Default arguments are not considered to be arguments in this
+    context; they only become arguments after a function has been
+    selected.
+[^13]: Although the *template-argument* corresponding to a
+    *template-parameter* of type `bool` may be deduced from an array
+    bound, the resulting value will always be `true` because the array
+    bound will be nonzero.
+[^14]: The parameters of function template specializations contain no
+    template parameter types. The set of conversions allowed on deduced
+    arguments is limited, because the argument deduction process
+    produces function templates with parameters that either match the
+    call arguments exactly or differ only in ways that can be bridged by
+    the allowed limited conversions. Non-deduced arguments allow the
+    full range of conversions. Note also that  [[over.match.best]]
+    specifies that a non-template function will be given preference over
+    a template specialization if the two functions are otherwise equally
+    good candidates for an overload match.

Diff to HTML by rtfpessoa