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

Files changed (1) hide show

tmp/tmpj4jxlzss/{from.md → to.md} +289 -222

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

@@ -1,7 +1,9 @@
 ## Function template specializations <a id="temp.fct.spec">[[temp.fct.spec]]</a>
 A function instantiated from a function template is called a function
 template specialization; so is an explicit specialization of a function
 template. Template arguments can be explicitly specified when naming the
 function template specialization, deduced from the context (e.g.,
 deduced from the function arguments in a call to the function template
@@ -59,12 +61,11 @@ void g(double d) {
 ```
 — *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,
@@ -74,20 +75,19 @@ specialization of a function template
 - 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
-template arguments, identifies a single function template
-specialization, then the *template-id* is an lvalue for the function
-template specialization.
 [*Example 2*:
 ``` cpp
 template<class X, class Y> X f(Y);
@@ -103,11 +103,11 @@ void h() {
 }
 ```
 — *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:
@@ -146,11 +146,11 @@ void g() {
 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,
 ``` cpp
@@ -165,11 +165,11 @@ void g() {
 }
 ```
 — *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*]
@@ -189,10 +189,12 @@ void g() {
 — *end example*]
 ### Template argument deduction <a id="temp.deduct">[[temp.deduct]]</a>
 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.
@@ -287,45 +289,90 @@ void g() {
 — *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
-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
 arguments. This is done at the beginning of template argument deduction
 when any explicitly specified template arguments are substituted into
 the function type, and again at the end of template argument deduction
 when any template arguments that were deduced or obtained from default
 arguments are substituted.
 The substitution occurs in all types and expressions that are used in
-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. 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*]
-[*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(...) { }
@@ -344,38 +391,37 @@ void x() {
 — *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, 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(...);
@@ -404,11 +450,11 @@ j(0);               // deduction fails on #1, calls #2
 — *end example*]
 — *end note*]
-[*Example 7*:
 ``` cpp
 struct X { };
 struct Y {
   Y(X) {}
@@ -421,30 +467,30 @@ X x1, x2;
 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);
   ```
@@ -455,17 +501,17 @@ 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 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>*) {}
-  template <class T> void h(Z<T::template TT>*){}
   struct A {};
   struct B { int Y; };
   struct C {
     typedef int N;
   };
@@ -485,44 +531,46 @@ 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 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
@@ -708,15 +756,17 @@ that allow a difference:
   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
@@ -775,62 +825,33 @@ 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 9*:
-``` 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]]. 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>
 Template argument deduction is done by comparing the return type of the
-conversion function template (call it `P`) with the type that is
-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 subclause.
@@ -848,26 +869,24 @@ If `A` is not a reference type:
 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
-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.
@@ -889,11 +908,11 @@ as the parameter template.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
-  parameter types for which the function call has arguments.[^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.
@@ -1034,12 +1053,12 @@ 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
- 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.
@@ -1112,14 +1131,14 @@ 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
 }
 ```
 Here is an example where two template arguments are deduced from a
 single function parameter/argument pair. This can lead to conflicts that
@@ -1131,13 +1150,32 @@ template <class T, class U> void f(  T (*)( T, U, U )  );
 int g1( int, float, float);
 char g2( int, float, float);
 int g3( int, char, float);
 void r() {
-  f(g1);            // OK: T is int and U is float
-  f(g2);            // error: T could be char or int
-  f(g3);            // error: U could be char or float
 }
 ```
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument
@@ -1167,49 +1205,50 @@ void t() {
 }
 ```
 — *end example*]
-A template type argument `T`, a template template argument `TT` or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
-T
-cv T
 T*
 T&
 T&&
-T[integer-constant]
-template-name<T>  (where template-name refers to a class template)
-type(T)
-T()
-T(T)
-T type::*
-type T::*
-T T::*
-T (type::*)()
-type (T::*)()
-type (type::*)(T)
-type (T::*)(T)
-T (type::*)(T)
-T (T::*)()
-T (T::*)(T)
-type[i]
-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`.
 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
@@ -1253,11 +1292,11 @@ 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*:
@@ -1360,23 +1399,40 @@ 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*:
 ``` 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
@@ -1384,28 +1440,28 @@ 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 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*]
-[*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>);
@@ -1420,11 +1476,11 @@ void k() {
 — *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
@@ -1444,13 +1500,16 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 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 { ... };
 template<short s> void f(A<s>);
 void k1() {
@@ -1461,20 +1520,20 @@ void k1() {
 template<const short cs> class B { };
 template<short s> void g(B<s>);
 void k2() {
   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);
@@ -1482,38 +1541,38 @@ void g(char,int);
 void h(int,int,int);
 void h(char,int);
 int m() {
   f(&g);            // error: ambiguous
-  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 { };
@@ -1521,15 +1580,15 @@ 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 { };
@@ -1539,11 +1598,11 @@ template<class ... Types> int f(void (*)(Types ...));
 void g(int, float);
 X<int> x1;                      // uses primary template
 X<int(int, float, double)> x2;  // uses partial specialization; ArgTypes contains float, double
 X<int(float, int)> x3;          // uses primary template
-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
 ```
@@ -1555,12 +1614,12 @@ 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]].
@@ -1570,29 +1629,30 @@ 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; }
@@ -1609,11 +1669,11 @@ Adding the non-template function
 ``` cpp
 int max(int,int);
 ```
 to the example above would resolve the third call, by providing a
-function that could be called for `max(a,c)` after using the standard
 conversion of `char` to `int` for `c`.
 — *end example*]
 [*Example 2*:
@@ -1663,46 +1723,42 @@ a template specialization is a candidate.
 ``` cpp
 template<class T> void f(T);    // declaration
 void g() {
-  f("Annemarie");               // call of f<const char*>
 }
 ```
-The call of `f` is well-formed even if the template `f` is only declared
 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*]
 <!-- 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
@@ -1711,11 +1767,10 @@ explicitly generated, is present in some translation unit.
 [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
@@ -1725,106 +1780,119 @@ explicitly generated, is present in some translation unit.
 [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.
@@ -1838,51 +1906,50 @@ explicitly generated, is present in some translation unit.
     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

 ## Function template specializations <a id="temp.fct.spec">[[temp.fct.spec]]</a>
+### General <a id="temp.fct.spec.general">[[temp.fct.spec.general]]</a>
 A function instantiated from a function template is called a function
 template specialization; so is an explicit specialization of a function
 template. Template arguments can be explicitly specified when naming the
 function template specialization, deduced from the context (e.g.,
 deduced from the function arguments in a call to the function template
 ```
 — *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,
 - 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.
+[*Note 1*: A trailing template parameter pack [[temp.variadic]] not
+otherwise deduced will be deduced as an empty sequence of template
+arguments. — *end note*]
+If all of the template arguments can be deduced or obtained from default
+*template-argument*s, they may all be omitted; in this case, the empty
+template argument list `<>` itself may also be omitted.
 [*Example 2*:
 ``` cpp
 template<class X, class Y> X f(Y);
 }
 ```
 — *end example*]
+[*Note 2*:
 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:
 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 3*:
 Template parameters do not participate in template argument deduction if
 they are explicitly specified. For example,
 ``` cpp
 }
 ```
 — *end note*]
+[*Note 4*: 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*]
 — *end example*]
 ### Template argument deduction <a id="temp.deduct">[[temp.deduct]]</a>
+#### General <a id="temp.deduct.general">[[temp.deduct.general]]</a>
 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.
 — *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 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. In the context of a
+function call, if type deduction has not yet failed, then for those
+function parameters for which the function call has arguments, each
+function parameter with a type that was non-dependent before
+substitution of any explicitly-specified template arguments is checked
+against its corresponding argument; if the corresponding argument cannot
+be implicitly converted to the parameter type, type deduction fails.
+[*Note 3*: Overload resolution will check the other parameters,
+including parameters with dependent types in which no template
+parameters participate in template argument deduction and parameters
+that became non-dependent due to substitution of explicitly-specified
+template arguments. — *end note*]
+If type deduction has not yet failed, then all uses of template
+parameters in 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.
+[*Example 5*:
+``` cpp
+template <class T> struct Z {
+  typedef typename T::x xx;
+};
+template <class T> concept C = requires { typename T::A; };
+template <C T> typename Z<T>::xx f(void *, T);          // #1
+template <class T> void f(int, T);                      // #2
+struct A {} a;
+struct ZZ {
+  template <class T, class = typename Z<T>::xx> operator T *();
+  operator int();
+};
+int main() {
+  ZZ zz;
+  f(1, a);              // OK, deduction fails for #1 because there is no conversion from int to void*
+  f(zz, 42);            // OK, deduction fails for #1 because C<int> is not satisfied
+}
+```
+— *end example*]
 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
 arguments. This is done at the beginning of template argument deduction
 when any explicitly specified template arguments are substituted into
 the function type, and again at the end of template argument deduction
 when any template arguments that were deduced or obtained from default
 arguments are substituted.
+The *deduction substitution loci* are
+- the function type outside of the *noexcept-specifier*,
+- the *explicit-specifier*, and
+- the template parameter declarations.
 The substitution occurs in all types and expressions that are used in
+the deduction substitution loci. The expressions include not only
+constant expressions such as those that appear in array bounds or as
+nontype template arguments but also general expressions (i.e.,
+non-constant expressions) inside `sizeof`, `decltype`, and other
+contexts that allow non-constant expressions. The substitution proceeds
+in lexical order and stops when a condition that causes deduction to
+fail is encountered. If substitution into different declarations of the
+same function template would cause template instantiations to occur in a
+different order or not at all, the program is ill-formed; no diagnostic
+required.
+[*Note 4*: The equivalent substitution in exception specifications is
 done only when the *noexcept-specifier* is instantiated, at which point
 a program is ill-formed if the substitution results in an invalid type
 or expression. — *end note*]
+[*Example 6*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
 template <class T> typename T::X f(typename A<T>::X);
 template <class T> void f(...) { }
 — *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 in the same context
+using the substituted arguments.
+[*Note 5*: If no diagnostic is required, the program is still
 ill-formed. Access checking is done as part of the substitution
 process. — *end note*]
+Invalid types and expressions can result in a deduction failure only in
+the immediate context of the deduction substitution loci.
+[*Note 6*: 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 7*:
 The intent is to avoid requiring implementations to deal with
 substitution failure involving arbitrary statements.
+[*Example 7*:
 ``` cpp
 template <class T>
   auto f(T) -> decltype([]() { T::invalid; } ());
 void f(...);
 — *end example*]
 — *end note*]
+[*Example 8*:
 ``` 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 8*:
+Type deduction can 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 9*:
   ``` 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 10*:
   ``` 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 11*:
   ``` 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>*) {}
+  template <class T> void h(Z<T::TT>*) {}
   struct A {};
   struct B { int Y; };
   struct C {
     typedef int 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 12*:
   ``` 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 13*:
   ``` cpp
   template <class T, T> struct S {};
+  template <class T> int f(S<T, T{}>*);   // #1
+ class X {
+ int m;
+  };
+  int i0 = f<X>(0);   // #1 uses a value of non-structural type X as a non-type template argument
   ```
   — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
   declaration.
+  \[*Example 14*:
   ``` cpp
   template <class T, T*> int f(int);
+  int i2 = f<int,1>(0);           // can't convert 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 15*:
 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
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
     struct X<T, Ts...> : X<Ts...> {};
   struct D : X<int> {};
+  struct E : X<>, 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>
+  int z = f(E());     // calls f<int>, not f<>
   ```
   — *end example*]
 These alternatives are considered only if type deduction would otherwise
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
 #### Deducing template arguments taking the address of a function template <a id="temp.deduct.funcaddr">[[temp.deduct.funcaddr]]</a>
 Template arguments can be deduced from the type specified when taking
+the address of an overload set [[over.over]]. If there is a target, the
+function template’s function type and the target type are used as the
+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>
 Template argument deduction is done by comparing the return type of the
+conversion function template (call it `P`) with the type specified by
+the *conversion-type-id* of the *conversion-function-id* being looked up
+(call it `A`) as described in  [[temp.deduct.type]]. If the
+*conversion-function-id* is constructed during overload resolution
+[[over.match.funcs]], the rules in the remainder of this subclause
+apply.
 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 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, certain
+attributes of `A` may be ignored:
+- If the original `A` is a reference type, any cv-qualifiers of `A`
+  (i.e., the type referred to by the reference).
+- If the original `A` is a function pointer or
+ pointer-to-member-function type with a potentially-throwing exception
+  specification [[except.spec]], the exception specification.
+- Any cv-qualifiers in `A` that can be restored by a qualification
+ conversion.
+These attributes are ignored only if type deduction would otherwise
+fail. If ignoring them allows 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.[^13]
 - In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts [[temp.func.order]] the function template’s function
   type is used.
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
 templates, and non-type values:
+- A function type includes the types of each of the function parameters,
+  the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
   includes the types, templates, and non-type values referenced by the
   template argument list of the specialization.
 ``` 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 deduced as both A and B
+  f(b,a);           // error: T deduced as both A and B
+  f(a,a);           // OK, T is A
+  f(b,b);           // OK, T is B
 }
 ```
 Here is an example where two template arguments are deduced from a
 single function parameter/argument pair. This can lead to conflicts that
 int g1( int, float, float);
 char g2( int, float, float);
 int g3( int, char, float);
 void r() {
+  f(g1);            // OK, T is int and U is float
+  f(g2);            // error: T deduced as both char and int
+  f(g3);            // error: U deduced as both char and float
+}
+```
+Here is an example where the exception specification of a function type
+is deduced:
+``` cpp
+template<bool E> void f1(void (*)() noexcept(E));
+template<bool> struct A { };
+template<bool B> void f2(void (*)(A<B>) noexcept(B));
+void g1();
+void g2() noexcept;
+void g3(A<true>);
+void h() {
+  f1(g1);           // OK, E is false
+  f1(g2);           // OK, E is true
+  f2(g3);           // error: B deduced as both true and false
 }
 ```
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument
 }
 ```
 — *end example*]
+A template type argument `T`, a template template argument `TT`, or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
+\opt{cv} T
 T*
 T&
 T&&
+\opt{T}[\opt{i}]
+\opt{T}(\opt{T}) noexcept(\opt{i})
+\opt{T} \opt{T}::*
+\opt{TT}<T>
+\opt{TT}<i>
+\opt{TT}<TT>
+\opt{TT}<>
 ```
+where
+- `\opt{T}` represents a type or parameter-type-list that either
+  satisfies these rules recursively, is a non-deduced context in `P` or
+ `A`, or is the same non-dependent type in `P` and `A`,
+- `\opt{TT}` represents either a class template or a template template
+  parameter,
+- `\opt{i}` represents an expression that either is an `i`, is
+  value-dependent in `P` or `A`, or has the same constant value in `P`
+  and `A`, and
+- `noexcept(\opt{i})` represents an exception specification
+  [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
+  *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
+  above.
+[*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
+`TT`s, deduction is not possible. — *end note*]
+Similarly, `<T>` represents template argument lists where at least one
+argument contains a `T`, `<i>` represents template argument lists where
+at least one argument contains an `i` and `<>` represents template
+argument lists where no argument contains a `T` or an `i`.
 If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
 the respective template argument list of `P` is compared with the
 corresponding argument Aᵢ of the corresponding template argument list of
 `A`. If the template argument list of `P` contains a pack expansion that
 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 3*: 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*:
 using V = S<int[42]>::Q;        // OK; T was deduced as std::size_t from the type int[42]
 ```
 — *end example*]
+The type of `B` in the *noexcept-specifier* `noexcept(B)` of a function
+type is `bool`.
 [*Example 10*:
+``` cpp
+template<bool> struct A { };
+template<auto> struct B;
+template<auto X, void (*F)() noexcept(X)> struct B<F> {
+  A<X> ax;
+};
+void f_nothrow() noexcept;
+B<f_nothrow> bn;                // OK, type of X deduced as bool
+```
+— *end example*]
+[*Example 11*:
 ``` 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 4*:
 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 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*]
+[*Note 5*:
 If, in the declaration of a function template with a non-type template
 parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
+[*Example 12*:
 ``` cpp
 template <int i> class A { ... };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 — *end example*]
 — *end note*]
+[*Note 6*:
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
 named by the enclosing *simple-template-id*, deduction fails. If `P` has
 a form that contains `[i]`, and if the type of `i` is not an integral
+type, deduction fails.[^14]
+If `P` has a form that includes `noexcept(i)` and the type of `i` is not
+`bool`, deduction fails.
+[*Example 13*:
 ``` cpp
 template<int i> class A { ... };
 template<short s> void f(A<s>);
 void k1() {
 template<const short cs> class B { };
 template<short s> void g(B<s>);
 void k2() {
   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 14*:
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void h(int,int,int);
 void h(char,int);
 int m() {
   f(&g);            // error: ambiguous
+  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 15*:
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
+  f(1);             // OK, calls f<int>(1,7)
   f();              // error: cannot deduce T
+  f<int>();         // OK, calls 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 16*:
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 f(ab);              // calls f(A<B>)
 ```
 — *end example*]
+[*Note 7*: Template argument deduction involving parameter packs
 [[temp.variadic]] can deduce zero or more arguments for each parameter
 pack. — *end note*]
+[*Example 17*:
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
 void g(int, float);
 X<int> x1;                      // uses primary template
 X<int(int, float, double)> x2;  // uses partial specialization; ArgTypes contains float, double
 X<int(float, int)> x3;          // uses primary template
+Y<> y1;                         // uses 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
 ```
 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]].
 [[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 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 or, for conversion function templates,
+that can convert to the required type. 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 functions found by name lookup. The synthesized
 declarations are treated like any other functions in the remainder of
 overload resolution, except as explicitly noted in
+[[over.match.best]].[^15]
 [*Example 1*:
 ``` cpp
 template<class T> T max(T a, T b) { return a>b?a:b; }
 ``` cpp
 int max(int,int);
 ```
 to the example above would resolve the third call, by providing a
+function that can be called for `max(a,c)` after using the standard
 conversion of `char` to `int` for `c`.
 — *end example*]
 [*Example 2*:
 ``` cpp
 template<class T> void f(T);    // declaration
 void g() {
+  f("Annemarie");               // calls f<const char*>
 }
 ```
+The call to `f` is well-formed even if the template `f` is only declared
 and not defined at the point of the call. The program will be ill-formed
+unless a specialization for `f<const char*>` is explicitly instantiated
+in some translation unit [[temp.pre]].
 — *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.qual]: basic.md#basic.lookup.qual
 [basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.scope.scope]: basic.md#basic.scope.scope
 [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.local]: class.md#class.local
 [class.mem]: class.md#class.mem
+[class.member.lookup]: basic.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.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.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.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
+[depr.template.template]: future.md#depr.template.template
 [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.qual]: expr.md#expr.prim.id.qual
 [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.prim.this]: expr.md#expr.prim.this
 [expr.ref]: expr.md#expr.ref
 [expr.sizeof]: expr.md#expr.sizeof
+[expr.type.conv]: expr.md#expr.type.conv
 [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
+[module.unit]: module.md#module.unit
 [namespace.udecl]: dcl.md#namespace.udecl
 [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.funcs]: over.md#over.match.funcs
 [over.match.oper]: over.md#over.match.oper
 [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.general]: #temp.arg.general
 [temp.arg.nontype]: #temp.arg.nontype
 [temp.arg.template]: #temp.arg.template
 [temp.arg.type]: #temp.arg.type
 [temp.class]: #temp.class
+[temp.class.general]: #temp.class.general
 [temp.concept]: #temp.concept
 [temp.constr]: #temp.constr
 [temp.constr.atomic]: #temp.constr.atomic
 [temp.constr.constr]: #temp.constr.constr
+[temp.constr.constr.general]: #temp.constr.constr.general
 [temp.constr.decl]: #temp.constr.decl
+[temp.constr.general]: #temp.constr.general
 [temp.constr.normal]: #temp.constr.normal
 [temp.constr.op]: #temp.constr.op
 [temp.constr.order]: #temp.constr.order
 [temp.decls]: #temp.decls
+[temp.decls.general]: #temp.decls.general
 [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.general]: #temp.deduct.general
 [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.general]: #temp.dep.general
 [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.general]: #temp.fct.general
 [temp.fct.spec]: #temp.fct.spec
+[temp.fct.spec.general]: #temp.fct.spec.general
 [temp.fold.empty]: #temp.fold.empty
 [temp.friend]: #temp.friend
 [temp.func.order]: #temp.func.order
 [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.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.res.general]: #temp.res.general
 [temp.spec]: #temp.spec
+[temp.spec.general]: #temp.spec.general
+[temp.spec.partial]: #temp.spec.partial
+[temp.spec.partial.general]: #temp.spec.partial.general
+[temp.spec.partial.match]: #temp.spec.partial.match
+[temp.spec.partial.member]: #temp.spec.partial.member
+[temp.spec.partial.order]: #temp.spec.partial.order
 [temp.static]: #temp.static
 [temp.type]: #temp.type
 [temp.variadic]: #temp.variadic
+[term.incomplete.type]: basic.md#term.incomplete.type
+[term.odr.use]: basic.md#term.odr.use
 [^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.
     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. 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).
 [^5]: A constraint is in conjunctive normal form when it is a
     conjunction of clauses where each clause is a disjunction of atomic
+    constraints. 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).
 [^6]: The identity of enumerators is not preserved.
 [^7]: An array as a *template-parameter* decays to a pointer.
+[^8]: There is no context in which they would 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
+    [[term.odr.use]] 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]: Every instantiation of a class template declares a different set
+ of assignment operators.
+[^12]: This includes an injected-class-name [[class.pre]] of a class
+    template used without a *template-argument-list*.
+[^13]: Default arguments are not considered to be arguments in this
     context; they only become arguments after a function has been
     selected.
+[^14]: Although the *template-argument* corresponding to a
+    *template-parameter* of type `bool` can be deduced from an array
     bound, the resulting value will always be `true` because the array
     bound will be nonzero.
+[^15]: 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

Diff to HTML by rtfpessoa