[temp] - C++20 → C++23

Files changed (1) hide show

tmp/tmp2smd35p7/{from.md → to.md} +1142 -1399

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

@@ -38,11 +38,11 @@ constraint-logical-and-expression:
   primary-expression
   constraint-logical-and-expression '&&' primary-expression
 ```
 [*Note 1*: The `>` token following the *template-parameter-list* of a
-*template-declaration* may be the product of replacing a `>{>}` token by
 two consecutive `>` tokens [[temp.names]]. — *end note*]
 The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
@@ -78,49 +78,44 @@ struct matrix_constants {
 };
 ```
 — *end example*]
-A *template-declaration* can appear only as a namespace scope or class
-scope declaration. Its *declaration* shall not be an
-*export-declaration*. In a function template declaration, the last
-component of the *declarator-id* shall not be a *template-id*.
-[*Note 2*: That last component may be an *identifier*, an
-*operator-function-id*, a *conversion-function-id*, or a
-*literal-operator-id*. In a class template declaration, if the class
-name is a *simple-template-id*, the declaration declares a class
-template partial specialization [[temp.class.spec]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
 instantiation the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
-A template name has linkage [[basic.link]]. Specializations (explicit or
-implicit) of a template that has internal linkage are distinct from all
-specializations in other translation units. A template, a template
-explicit specialization [[temp.expl.spec]], and a class template partial
-specialization shall not have C linkage. Use of a linkage specification
-other than `"C"` or `"C++"` with any of these constructs is
-conditionally-supported, with *implementation-defined* semantics.
-Template definitions shall obey the one-definition rule
-[[basic.def.odr]].
-[*Note 3*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
-of template instantiation [[temp.decls]] and must also obey the
-one-definition rule. — *end note*]
-A class template shall not have the same name as any other template,
-class, function, variable, enumeration, enumerator, namespace, or type
-in the same scope [[basic.scope]], except as specified in
-[[temp.class.spec]]. Except that a function template can be overloaded
-either by non-template functions [[dcl.fct]] with the same name or by
-other function templates with the same name [[temp.over]], a template
-name declared in namespace scope or in class scope shall be unique in
-that scope.
 An entity is *templated* if it is
 - a template,
 - an entity defined [[basic.def]] or created [[class.temporary]] in a
@@ -128,23 +123,29 @@ An entity is *templated* if it is
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
-[*Note 4*: A local class, a local variable, or a friend function
-defined in a templated entity is a templated entity. — *end note*]
 A *template-declaration* is written in terms of its template parameters.
 The optional *requires-clause* following a *template-parameter-list*
 allows the specification of constraints [[temp.constr.decl]] on template
 arguments [[temp.arg]]. The *requires-clause* introduces the
 *constraint-expression* that results from interpreting the
 *constraint-logical-or-expression* as a *constraint-expression*. The
 *constraint-logical-or-expression* of a *requires-clause* is an
 unevaluated operand [[expr.context]].
-[*Note 5*:
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.
@@ -196,20 +197,24 @@ type-parameter-key:
 type-constraint:
   nested-name-specifierₒₚₜ concept-name
   nested-name-specifierₒₚₜ concept-name '<' template-argument-listₒₚₜ '>'
 ```
 [*Note 1*: The `>` token following the *template-parameter-list* of a
-*type-parameter* may be the product of replacing a `>{>}` token by two
 consecutive `>` tokens [[temp.names]]. — *end note*]
 There is no semantic difference between `class` and `typename` in a
 *type-parameter-key*. `typename` followed by an *unqualified-id* names a
 template type parameter. `typename` followed by a *qualified-id* denotes
-the type in a non-type [^1] *parameter-declaration*. A
-*template-parameter* of the form `class` *identifier* is a
-*type-parameter*.
 [*Example 1*:
 ``` cpp
 class T { ... };
@@ -228,18 +233,19 @@ unnamed non-type *template-parameter* of class `T`.
 A storage class shall not be specified in a *template-parameter*
 declaration. Types shall not be defined in a *template-parameter*
 declaration.
-A *type-parameter* whose identifier does not follow an ellipsis defines
 its *identifier* to be a *typedef-name* (if declared without `template`)
 or *template-name* (if declared with `template`) in the scope of the
 template declaration.
 [*Note 2*:
-A template argument may be a class template or alias template. For
 example,
 ``` cpp
 template<class T> class myarray { ... };
@@ -297,11 +303,11 @@ A *structural type* is one of the following:
 - an lvalue reference type, or
 - a literal class type with the following properties:
   - all base classes and non-static data members are public and
     non-mutable and
   - the types of all bases classes and non-static data members are
-    structural types or (possibly multi-dimensional) array thereof.
 An *id-expression* naming a non-type *template-parameter* of class type
 `T` denotes a static storage duration object of type `const T`, known as
 a *template parameter object*, whose value is that of the corresponding
 template argument after it has been converted to the type of the
@@ -324,13 +330,13 @@ template<const X& x, int i, A a> void f() {
   i++;                          // error: change of template-parameter value
   &x;                           // OK
   &i;                           // error: address of non-reference template-parameter
   &a;                           // OK
-  int& ri = i;                  // error: non-const reference bound to temporary
-  const int& cri = i;           // OK: const reference bound to temporary
-  const A& ra = a;              // OK: const reference bound to a template parameter object
 }
 ```
 — *end example*]
@@ -380,14 +386,14 @@ specified after `=` in a *template-parameter*. A default
 parameter pack [[temp.variadic]]. A default *template-argument* may be
 specified in a template declaration. A default *template-argument* shall
 not be specified in the *template-parameter-list*s of the definition of
 a member of a class template that appears outside of the member’s class.
 A default *template-argument* shall not be specified in a friend class
-template declaration. If a friend function template declaration
 specifies a default *template-argument*, that declaration shall be a
-definition and shall be the only declaration of the function template in
-the translation unit.
 The set of default *template-argument*s available for use is obtained by
 merging the default arguments from all prior declarations of the
 template in the same way default function arguments are
 [[dcl.fct.default]].
@@ -431,27 +437,15 @@ template<class... T, class... U> void f() { }   // error
 template<class... T, class U> void g() { }      // error
 ```
 — *end example*]
-A *template-parameter* shall not be given default arguments by two
-different declarations in the same scope.
-[*Example 8*:
-``` cpp
-template<class T = int> class X;
-template<class T = int> class X { ... };  // error
-```
-— *end example*]
 When parsing a default *template-argument* for a non-type
 *template-parameter*, the first non-nested `>` is taken as the end of
 the *template-parameter-list* rather than a greater-than operator.
-[*Example 9*:
 ``` cpp
 template<int i = 3 > 4 >        // syntax error
 class X { ... };
@@ -464,11 +458,11 @@ class Y { ... };
 A *template-parameter* of a template *template-parameter* is permitted
 to have a default *template-argument*. When such default arguments are
 specified, they apply to the template *template-parameter* in the scope
 of the template *template-parameter*.
-[*Example 10*:
 ``` cpp
 template <template <class TT = float> class T> struct A {
   inline void f();
   inline void g();
@@ -494,11 +488,11 @@ unexpanded packs is a pack expansion. A type parameter pack with a
 *type-constraint* that contains an unexpanded parameter pack is a pack
 expansion. A template parameter pack that is a pack expansion shall not
 expand a template parameter pack declared in the same
 *template-parameter-list*.
-[*Example 11*:
 ``` cpp
 template <class... Types>                       // Types is a template type parameter pack
    class Tuple;                                 // but not a pack expansion
@@ -549,41 +543,60 @@ template-argument:
   constant-expression
   type-id
   id-expression
 ```
-[*Note 1*: The name lookup rules [[basic.lookup]] are used to associate
-the use of a name with a template declaration; that is, to identify a
-name as a *template-name*. — *end note*]
-For a *template-name* to be explicitly qualified by the template
-arguments, the name must be considered to refer to a template.
-[*Note 2*: Whether a name actually refers to a template cannot be known
-in some cases until after argument dependent lookup is done
-[[basic.lookup.argdep]]. — *end note*]
-A name is considered to refer to a template if name lookup finds a
-*template-name* or an overload set that contains a function template. A
-name is also considered to refer to a template if it is an
-*unqualified-id* followed by a `<` and name lookup either finds one or
-more functions or finds nothing.
-When a name is considered to be a *template-name*, and it is followed by
-a `<`, the `<` is always taken as the delimiter of a
-*template-argument-list* and never as the less-than operator. When
-parsing a *template-argument-list*, the first non-nested `>`[^2] is
-taken as the ending delimiter rather than a greater-than operator.
-Similarly, the first non-nested `>{>}` is treated as two consecutive but
 distinct `>` tokens, the first of which is taken as the end of the
 *template-argument-list* and completes the *template-id*.
-[*Note 3*: The second `>` token produced by this replacement rule may
-terminate an enclosing *template-id* construct or it may be part of a
 different construct (e.g., a cast). — *end note*]
-[*Example 1*:
 ``` cpp
 template<int i> class X { ... };
 X< 1>2 > x1;                            // syntax error
@@ -595,53 +608,25 @@ Y<X<6>>1>> x4;                          // syntax error
 Y<X<(6>>1)>> x5;                        // OK
 ```
 — *end example*]
-The keyword `template` is said to appear at the top level in a
-*qualified-id* if it appears outside of a *template-argument-list* or
-*decltype-specifier*. In a *qualified-id* of a *declarator-id* or in a
-*qualified-id* formed by a *class-head-name* [[class.pre]] or
-*enum-head-name* [[dcl.enum]], the keyword `template` shall not appear
-at the top level. In a *qualified-id* used as the name in a
-*typename-specifier* [[temp.res]], *elaborated-type-specifier*
-[[dcl.type.elab]], *using-declaration* [[namespace.udecl]], or
-*class-or-decltype* [[class.derived]], an optional keyword `template`
-appearing at the top level is ignored. In these contexts, a `<` token is
-always assumed to introduce a *template-argument-list*. In all other
-contexts, when naming a template specialization of a member of an
-unknown specialization [[temp.dep.type]], the member template name shall
-be prefixed by the keyword `template`.
-[*Example 2*:
-``` cpp
-struct X {
-  template<std::size_t> X* alloc();
-  template<std::size_t> static X* adjust();
-};
-template<class T> void f(T* p) {
-  T* p1 = p->alloc<200>();              // error: < means less than
-  T* p2 = p->template alloc<200>();     // OK: < starts template argument list
-  T::adjust<100>();                     // error: < means less than
-  T::template adjust<100>();            // OK: < starts template argument list
-}
-```
-— *end example*]
-A name prefixed by the keyword `template` shall be a *template-id* or
-the name shall refer to a class template or an alias template.
-[*Note 4*: The keyword `template` may not be applied to non-template
 members of class templates. — *end note*]
-[*Note 5*: As is the case with the `typename` prefix, the `template`
-prefix is allowed in cases where it is not strictly necessary; i.e.,
-when the *nested-name-specifier* or the expression on the left of the
-`->` or `.` is not dependent on a *template-parameter*, or the use does
-not appear in the scope of a template. — *end note*]
 [*Example 3*:
 ``` cpp
 template <class T> struct A {
@@ -649,19 +634,19 @@ template <class T> struct A {
   template <class U> void f(U);
 };
 template <class T> void f(T t) {
   A<T> a;
-  a.template f<>(t);                    // OK: calls template
   a.template f(t);                      // error: not a template-id
 }
 template <class T> struct B {
   template <class T2> struct C { };
 };
-// OK: T::template C names a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
 D<B<int> > db;
 ```
 — *end example*]
@@ -698,13 +683,12 @@ using T5 = X<S>;                // OK
 — *end example*]
 When the *template-name* of a *simple-template-id* names a constrained
 non-function template or a constrained template *template-parameter*,
-but not a member template that is a member of an unknown specialization
-[[temp.res]], and all *template-argument*s in the *simple-template-id*
-are non-dependent [[temp.dep.temp]], the associated constraints
 [[temp.constr.decl]] of the constrained template shall be satisfied
 [[temp.constr.constr]].
 [*Example 5*:
@@ -745,11 +729,11 @@ A *concept-id* is a *simple-template-id* where the *template-name* is a
 name a template specialization. A concept-id evaluates to `true` if the
 concept’s normalized *constraint-expression* [[temp.constr.decl]] is
 satisfied [[temp.constr.constr]] by the specified template arguments and
 `false` otherwise.
-[*Note 6*: Since a *constraint-expression* is an unevaluated operand, a
 concept-id appearing in a *constraint-expression* is not evaluated
 except as necessary to determine whether the normalized constraints are
 satisfied. — *end note*]
 [*Example 6*:
@@ -761,10 +745,12 @@ static_assert(C<int>);      // OK
 — *end example*]
 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
@@ -795,10 +781,17 @@ void bar() {
 }
 ```
 — *end example*]
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
 corresponding *template-parameter*.[^3]
 [*Example 2*:
@@ -812,17 +805,13 @@ void g() {
 }
 ```
 — *end example*]
-The name of a *template-argument* shall be accessible at the point where
-it is used as a *template-argument*.
-[*Note 1*: If the name of the *template-argument* is accessible at the
-point where it is used as a *template-argument*, there is no further
-access restriction in the resulting instantiation where the
-corresponding *template-parameter* name is used. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
@@ -830,13 +819,13 @@ template<class T> class X {
 };
 class Y {
 private:
   struct S { ... };
-  X<S> x;           // OK: S is accessible
                     // X<Y::S> has a static member of type Y::S
-                    // OK: even though Y::S is private
 };
 X<Y::S> y;          // error: S not accessible
 ```
@@ -869,14 +858,14 @@ brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
 ``` cpp
 template<class T = char> class String;
-String<>* p;                    // OK: String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
-Tuple<>* t;                     // OK: Elements is empty
 Tuple* u;                       // syntax error
 ```
 — *end example*]
@@ -889,26 +878,28 @@ that is a class template specialization may explicitly specify the
 ``` cpp
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
-  p->A<int>::~A();              // OK: destructor call
-  q->A<int>::~A<int>();         // OK: destructor call
 }
 ```
 — *end example*]
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
-When name lookup for the name in a *template-id* finds an overload set,
-both non-template functions in the overload set and function templates
-in the overload set for which the *template-argument*s do not match the
-*template-parameter*s are ignored. If none of the function templates
-have matching *template-parameter*s, the program is ill-formed.
 When a *simple-template-id* does not name a function, a default
 *template-argument* is implicitly instantiated [[temp.inst]] when the
 value of that default argument is needed.
@@ -953,12 +944,12 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 1*: A template type argument may be an incomplete type
-[[basic.types]]. — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
 If the type `T` of a *template-parameter* [[temp.param]] contains a
 placeholder type [[dcl.spec.auto]] or a placeholder for a deduced class
@@ -1080,22 +1071,21 @@ C<Y{X{1}.n}> c;                 // error: subobject of temporary object used to
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
 A *template-argument* for a template *template-parameter* shall be the
 name of a class template or an alias template, expressed as
-*id-expression*. When the *template-argument* names a class template,
-only primary class templates are considered when matching the template
-template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
-Any partial specializations [[temp.class.spec]] associated with the
-primary class template or primary variable template are considered when
-a specialization based on the template *template-parameter* is
-instantiated. If a specialization is not visible at the point of
-instantiation, and it would have been selected had it been visible, the
-program is ill-formed, no diagnostic required.
 [*Example 1*:
 ``` cpp
 template<class T> class A {     // primary template
@@ -1165,12 +1155,12 @@ template <class T1> struct A;
 template <class T1, class T2> struct B;
 template <int N> struct C;
 template <class T1, int N> struct D;
 template <class T1, class T2, int N = 17> struct E;
-eval<A<int>> eA;                // OK: matches partial specialization of eval
-eval<B<int, float>> eB;         // OK: matches partial specialization of eval
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
@@ -1218,18 +1208,22 @@ according to the partial ordering rules for function templates
 If the rewrite produces an invalid type, then `P` is not at least as
 specialized as `A`.
 ## Template constraints <a id="temp.constr">[[temp.constr]]</a>
-[*Note 1*: This subclause defines the meaning of constraints on
-template arguments. The abstract syntax and satisfaction rules are
 defined in [[temp.constr.constr]]. Constraints are associated with
 declarations in [[temp.constr.decl]]. Declarations are partially ordered
 by their associated constraints [[temp.constr.order]]. — *end note*]
 ### Constraints <a id="temp.constr.constr">[[temp.constr.constr]]</a>
 A *constraint* is a sequence of logical operations and operands that
 specifies requirements on template arguments. The operands of a logical
 operation are constraints. There are three different kinds of
 constraints:
@@ -1280,11 +1274,11 @@ template<typename T>
   requires (sizeof(T) > 1) && (get_value<T>())
     void f(T);      // has associated constraint sizeof(T) > 1 ∧ get_value<T>()
 void f(int);
-f('a'); // OK: calls f(int)
 ```
 In the satisfaction of the associated constraints [[temp.constr.decl]]
 of `f`, the constraint `sizeof(char) > 1` is not satisfied; the second
 operand is not checked for satisfaction.
@@ -1391,14 +1385,14 @@ void h() {
 }
 ```
 — *end example*]
-This similarity includes the situation where a program is ill-formed, no
-diagnostic required, when the meaning of the program depends on whether
-two constructs are equivalent, and they are functionally equivalent but
-not equivalent.
 [*Example 2*:
 ``` cpp
 template <unsigned N> void f2()
@@ -1599,11 +1593,11 @@ names a concept specialization [[expr.prim.id]]. — *end note*]
 ``` cpp
 template<typename T> concept C1 = sizeof(T) == 1;
 template<typename T> concept C2 = C1<T> && 1 == 2;
 template<typename T> concept C3 = requires { typename T::type; };
-template<typename T> concept C4 = requires (T x) { ++x; }
 template<C2 U> void f1(U);      // #1
 template<C3 U> void f2(U);      // #2
 template<C4 U> void f3(U);      // #3
 ```
@@ -1618,12 +1612,15 @@ mapping `T` ↦ `U`).
 — *end example*]
 ### Partial ordering by constraints <a id="temp.constr.order">[[temp.constr.order]]</a>
 A constraint P *subsumes* a constraint Q if and only if, for every
-disjunctive clause Pᵢ in the disjunctive normal form[^4] of P, Pᵢ
-subsumes every conjunctive clause Qⱼ in the conjunctive normal form[^5]
 of Q, where
 - a disjunctive clause Pᵢ subsumes a conjunctive clause Qⱼ if and only
   if there exists an atomic constraint Pᵢₐ in Pᵢ for which there exists
   an atomic constraint $Q_{jb}$ in Qⱼ such that Pᵢₐ subsumes $Q_{jb}$,
@@ -1645,11 +1642,11 @@ partial ordering is used to determine
 - the best viable candidate of non-template functions
   [[over.match.best]],
 - the address of a non-template function [[over.over]],
 - the matching of template template arguments [[temp.arg.template]],
 - the partial ordering of class template specializations
-  [[temp.class.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
 A declaration `D1` is *at least as constrained* as a declaration `D2` if
@@ -1753,56 +1750,56 @@ declares `y` and `z` to be of the same type.
 If an expression e is type-dependent [[temp.dep.expr]], `decltype(e)`
 denotes a unique dependent type. Two such *decltype-specifier*s refer to
 the same type only if their *expression*s are equivalent
 [[temp.over.link]].
-[*Note 1*: However, such a type may be aliased, e.g., by a
 *typedef-name*. — *end note*]
 ## Template declarations <a id="temp.decls">[[temp.decls]]</a>
-A *template-id*, that is, the *template-name* followed by a
-*template-argument-list* shall not be specified in the declaration of a
-primary template declaration.
-[*Example 1*:
-``` cpp
-template<class T1, class T2, int I> class A<T1, T2, I> { };     // error
-template<class T1, int I> void sort<T1, I>(T1 data[I]);         // error
-```
-— *end example*]
-[*Note 1*: However, this syntax is allowed in class template partial
-specializations [[temp.class.spec]]. — *end note*]
 For purposes of name lookup and instantiation, default arguments,
 *type-constraint*s, *requires-clause*s [[temp.pre]], and
 *noexcept-specifier*s of function templates and of member functions of
 class templates are considered definitions; each default argument,
 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
-definition or to any other default arguments *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
 are considered definitions.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
-A single class template `List` might provide an unbounded set of class
-definitions: one class `List<T>` for every type `T`, each describing a
-linked list of elements of type `T`. Similarly, a class template `Array`
-describing a contiguous, dynamic array might be defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
@@ -1812,26 +1809,25 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
-declared and that a *type-name* `T` may be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
-When a member function, a member class, a member enumeration, a static
-data member or a member template of a class template is defined outside
-of the class template definition, the member definition is defined as a
-template definition in which the *template-head* is equivalent to that
-of the class template [[temp.over.link]]. The names of the template
-parameters used in the definition of the member may be different from
-the template parameter names used in the class template definition. The
-template argument list following the class template name in the member
-definition shall name the parameters in the same order as the one used
-in the template parameter list of the member. Each template parameter
-pack shall be expanded with an ellipsis in the template argument list.
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
@@ -1862,11 +1858,11 @@ template<C T> struct S {
   void g();
   void h();
   template<D U> struct Inner;
 };
-template<C A> void S<A>::f() { }        // OK: template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
@@ -1874,13 +1870,15 @@ template<C X> template<D Y>
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
-In a redeclaration, partial specialization, explicit specialization or
-explicit instantiation of a class template, the *class-key* shall agree
-in kind with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
@@ -1897,11 +1895,11 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
-function might be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
@@ -1950,12 +1948,12 @@ v2[3] = dcomplex(7,8);                  // Array<dcomplex>::operator[]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
-template argument deduction [[over.match.class.deduct]], any deduction
-guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
@@ -1981,15 +1979,15 @@ S x{A()};           // x is of type S<short, int>
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
-the *simple-template-id*. A *deduction-guide* shall be declared in the
-same scope as the corresponding class template and, for a member class
-template, with the same access. Two deduction guide declarations in the
-same translation unit for the same class template shall not have
-equivalent *parameter-declaration-clause*s.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
@@ -2001,13 +1999,13 @@ instantiation [[temp.inst]]. For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
-A<int>::B* b1;                          // OK: requires A to be defined but not A::B
 template<class T> class A<T>::B { };
-A<int>::B  b2;                          // OK: requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
@@ -2043,11 +2041,11 @@ of unknown bound can have a different bound from its definition, if any.
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
-template <> int A<int>::i[] = { 1 };    // OK: 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
@@ -2139,11 +2137,11 @@ int main() {
 }
 ```
 — *end example*]
-A member function template shall not be virtual.
 [*Example 4*:
 ``` cpp
 template <class T> struct AA {
@@ -2164,19 +2162,21 @@ class B {
   virtual void f(int);
 };
 class D : public B {
   template <class T> void f(T); // does not override B::f(int)
-  void f(int i) { f<>(i); }     // overriding function that calls the template instantiation
 };
 ```
 — *end example*]
 A specialization of a conversion function template is referenced in the
 same way as a non-template conversion function that converts to the same
-type.
 [*Example 6*:
 ``` cpp
 struct A {
@@ -2193,27 +2193,15 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 1*: There is no syntax to form a *template-id* [[temp.names]] by
-providing an explicit template argument list [[temp.arg.explicit]] for a
-conversion function template [[class.conv.fct]]. — *end note*]
-A specialization of a conversion function template is not found by name
-lookup. Instead, any conversion function templates visible in the
-context of the use are considered. For each such operator, if argument
-deduction succeeds [[temp.deduct.conv]], the resulting specialization is
-used as if found by name lookup.
-A *using-declaration* in a derived class cannot refer to a
-specialization of a conversion function template in a base class.
-Overload resolution [[over.ics.rank]] and partial ordering
-[[temp.func.order]] are used to select the best conversion function
-among multiple specializations of conversion function templates and/or
-non-template conversion functions.
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 A *template parameter pack* is a template parameter that accepts zero or
 more template arguments.
@@ -2342,94 +2330,72 @@ template<class ... Args1> struct zip {
     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
-    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>{>}
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
-  void g(Args ... args) {                   // OK: Args is expanded by the function parameter pack args
-    f(const_cast<const Args*>(&args)...);   // OK: ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
-    f(h(args ...) + args ...);              // OK: first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
-The instantiation of a pack expansion that is neither a `sizeof...`
-expression nor a *fold-expression* produces a list of elements E₁, E₂,
-⋯, $\mathtt{E}_N$, where N is the number of elements in the pack
-expansion parameters. Each Eᵢ is generated by instantiating the pattern
-and replacing each pack expansion parameter with its iᵗʰ element. Such
-an element, in the context of the instantiation, is interpreted as
-follows:
-- if the pack is a template parameter pack, the element is a template
- parameter [[temp.param]] of the corresponding kind (type or non-type)
- designating the iᵗʰ corresponding type or value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
-  pack.
-All of the Eᵢ become items in the enclosing list.
-[*Note 1*: The variety of list varies with the context:
-*expression-list*, *base-specifier-list*, *template-argument-list*,
-etc. — *end note*]
-When N is zero, the instantiation of the expansion produces an empty
-list. Such an instantiation does not alter the syntactic interpretation
-of the enclosing construct, even in cases where omitting the list
-entirely would otherwise be ill-formed or would result in an ambiguity
-in the grammar.
-[*Example 6*:
-``` cpp
-template<class... T> struct X : T... { };
-template<class... T> void f(T... values) {
-  X<T...> x(values...);
-}
-template void f<>();    // OK: X<> has no base classes
-                        // x is a variable of type X<> that is value-initialized
-```
-— *end example*]
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
-an integral constant containing the number of elements in the pack it
-expands.
-The instantiation of a *fold-expression* produces:
-- `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a unary left fold,
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))` for a
-  unary right fold,
-- `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a
-  binary left fold, and
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$ *op*
-  E`)))` for a binary right fold.
-In each case, *op* is the *fold-operator*, N is the number of elements
-in the pack expansion parameters, and each Eᵢ is generated by
-instantiating the pattern and replacing each pack expansion parameter
-with its iᵗʰ element. For a binary fold-expression, E is generated by
-instantiating the *cast-expression* that did not contain an unexpanded
-pack.
-[*Example 7*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
@@ -2439,12 +2405,12 @@ bool b = all(true, true, true, false);
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
-If N is zero for a unary fold-expression, the value of the expression is
-shown in [[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
@@ -2452,29 +2418,39 @@ shown in [[temp.fold.empty]]; if the operator is not listed in
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
-template, or a non-template function or class. For a friend function
-declaration that is not a template declaration:
-- if the name of the friend is a qualified or unqualified *template-id*,
-  the friend declaration refers to a specialization of a function
-  template, otherwise,
-- if the name of the friend is a *qualified-id* and a matching
-  non-template function is found in the specified class or namespace,
-  the friend declaration refers to that function, otherwise,
-- if the name of the friend is a *qualified-id* and a matching function
-  template is found in the specified class or namespace, the friend
-  declaration refers to the deduced specialization of that function
-  template [[temp.deduct.decl]], otherwise,
-- the name shall be an *unqualified-id* that declares (or redeclares) a
-  non-template function.
 [*Example 1*:
 ``` cpp
 template<class T> class task;
@@ -2504,10 +2480,19 @@ function template `preempt` as a friend; and each specialization of the
 template has the class template specialization `task<int>` as a friend,
 and has all specializations of the class template `frd` as friends.
 — *end example*]
 A friend template may be declared within a class or class template. A
 friend function template may be defined within a class or class
 template, but a friend class template may not be defined in a class or
 class template. In these cases, all specializations of the friend class
 or friend function template are friends of the class or class template
@@ -2524,11 +2509,11 @@ class A {
 — *end example*]
 A template friend declaration specifies that all specializations of that
 template, whether they are implicitly instantiated [[temp.inst]],
-partially specialized [[temp.class.spec]] or explicitly specialized
 [[temp.expl.spec]], are friends of the class containing the template
 friend declaration.
 [*Example 3*:
@@ -2547,17 +2532,17 @@ template<class T> struct A<T*> { X::Y ab; };        // OK
 A template friend declaration may declare a member of a dependent type
 to be a friend. The friend declaration shall declare a function or
 specify a type with an *elaborated-type-specifier*, in either case with
 a *nested-name-specifier* ending with a *simple-template-id*, *C*, whose
 *template-name* names a class template. The template parameters of the
-template friend declaration shall be deducible from *C* (
-[[temp.deduct.type]]). In this case, a member of a specialization *S* of
 the class template is a friend of the class granting friendship if
 deduction of the template parameters of *C* from *S* succeeds, and
 substituting the deduced template arguments into the friend declaration
-produces a declaration that would be a valid redeclaration of the member
-of the specialization.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
@@ -2593,13 +2578,10 @@ class C {
 };                                              // of those function templates
 ```
 — *end example*]
-[*Note 1*: A friend declaration may first declare a member of an
-enclosing namespace scope [[temp.inject]]. — *end note*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 [*Example 5*:
@@ -2623,30 +2605,28 @@ definition. A friend function template with a constraint that depends on
 a template parameter from an enclosing template shall be a definition.
 Such a constrained friend function or function template declaration does
 not declare the same function or function template as a declaration in
 any other scope.
-### Class template partial specializations <a id="temp.class.spec">[[temp.class.spec]]</a>
-A *primary class template* declaration is one in which the class
-template name is an identifier. A template declaration in which the
-class template name is a *simple-template-id* is a *partial
-specialization* of the class template named in the *simple-template-id*.
-A partial specialization of a class template provides an alternative
 definition of the template that is used instead of the primary
 definition when the arguments in a specialization match those given in
-the partial specialization [[temp.class.spec.match]]. The primary
-template shall be declared before any specializations of that template.
-A partial specialization shall be declared before the first use of a
-class template specialization that would make use of the partial
-specialization as the result of an implicit or explicit instantiation in
-every translation unit in which such a use occurs; no diagnostic is
-required.
-Each class template partial specialization is a distinct template and
-definitions shall be provided for the members of a template partial
-specialization [[temp.class.spec.mfunc]].
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };
@@ -2660,11 +2640,11 @@ The first declaration declares the primary (unspecialized) class
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 — *end example*]
-A class template partial specialization may be constrained [[temp.pre]].
 [*Example 2*:
 ``` cpp
 template<typename T> concept C = true;
@@ -2681,38 +2661,18 @@ specialization succeeds, while the reverse does not. \#2 is more
 specialized because the template arguments are equivalent, but the
 partial specialization is more constrained [[temp.constr.order]].
 — *end example*]
-The template parameters are specified in the angle bracket enclosed list
-that immediately follows the keyword `template`. For partial
-specializations, the template argument list is explicitly written
-immediately following the class template name. For primary templates,
-this list is implicitly described by the template parameter list.
-Specifically, the order of the template arguments is the sequence in
-which they appear in the template parameter list.
-[*Example 3*: The template argument list for the primary template in
-the example above is `<T1,` `T2,` `I>`. — *end example*]
-[*Note 1*:
-The template argument list cannot be specified in the primary template
-declaration. For example,
-``` cpp
-template<class T1, class T2, int I>
-class A<T1, T2, I> { };                         // error
-```
-— *end note*]
-A class template partial specialization may be declared in any scope in
-which the corresponding primary template may be defined (
-[[namespace.memdef]], [[class.mem]], [[temp.mem]]).
-[*Example 4*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
@@ -2727,18 +2687,19 @@ template<class T> template<class T2>
 A<short>::C::B<int*> absip;                     // uses partial specialization #2
 ```
 — *end example*]
-Partial specialization declarations themselves are not found by name
-lookup. Rather, when the primary template name is used, any
-previously-declared partial specializations of the primary template are
-also considered. One consequence is that a *using-declaration* which
-refers to a class template does not restrict the set of partial
-specializations which may be found through the *using-declaration*.
-[*Example 5*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
@@ -2756,61 +2717,61 @@ A<int,int*> a;      // uses the partial specialization, which is found through t
 — *end example*]
 A non-type argument is non-specialized if it is the name of a non-type
 parameter. All other non-type arguments are specialized.
-Within the argument list of a class template partial specialization, the
-following restrictions apply:
 - The type of a template parameter corresponding to a specialized
-  non-type argument shall not be dependent on a parameter of the
   specialization.
-  \[*Example 6*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
   template< int X, int (*array_ptr)[X] > class A {};
   int array[5];
   template< int X > class A<X,&array> { };        // error
   ```
   — *end example*]
-- The specialization shall be more specialized than the primary template
-  [[temp.class.order]].
-- The template parameter list of a specialization shall not contain
-  default template argument values.[^8]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
 to specify template arguments of the *simple-template-id* of the partial
 specialization.
-[*Note 2*: The template arguments may be private types or objects that
 would normally not be accessible. Dependent names cannot be checked when
 declaring the partial specialization, but will be checked when
 substituting into the partial specialization. — *end note*]
-#### Matching of class template partial specializations <a id="temp.class.spec.match">[[temp.class.spec.match]]</a>
-When a class template is used in a context that requires an
-instantiation of the class, it is necessary to determine whether the
-instantiation is to be generated using the primary template or one of
-the partial specializations. This is done by matching the template
-arguments of the class template specialization with the template
-argument lists of the partial specializations.
-- If exactly one matching specialization is found, the instantiation is
-  generated from that specialization.
-- If more than one matching specialization is found, the partial order
-  rules [[temp.class.order]] are used to determine whether one of the
-  specializations is more specialized than the others. If none of the
- specializations is more specialized than all of the other matching
- specializations, then the use of the class template is ambiguous and
-  the program is ill-formed.
 - If no matches are found, the instantiation is generated from the
   primary template.
 A partial specialization matches a given actual template argument list
 if the template arguments of the partial specialization can be deduced
@@ -2868,21 +2829,22 @@ template <int I, int J, int K> struct B {};
 template <int I> struct B<I, I*2, 2> {};    // OK
 ```
 — *end example*]
-In a type name that refers to a class template specialization, (e.g.,
-`A<int, int, 1>`) the argument list shall match the template parameter
-list of the primary template. The template arguments of a specialization
-are deduced from the arguments of the primary template.
-#### Partial ordering of class template specializations <a id="temp.class.order">[[temp.class.order]]</a>
-For two class template partial specializations, the first is *more
-specialized* than the second if, given the following rewrite to two
-function templates, the first function template is more specialized than
-the second according to the ordering rules for function templates
 [[temp.func.order]]:
 - Each of the two function templates has the same template parameters
   and associated constraints [[temp.constr.decl]] as the corresponding
   partial specialization.
@@ -2936,26 +2898,20 @@ template<D T> void f(S<T>);     // B
 The partial specialization \#2 is more specialized than \#1 because `B`
 is more specialized than `A`.
 — *end example*]
-#### Members of class template specializations <a id="temp.class.spec.mfunc">[[temp.class.spec.mfunc]]</a>
-The template parameter list of a member of a class template partial
-specialization shall match the template parameter list of the class
-template partial specialization. The template argument list of a member
-of a class template partial specialization shall match the template
-argument list of the class template partial specialization. A class
-template partial specialization is a distinct template. The members of
-the class template partial specialization are unrelated to the members
-of the primary template. Class template partial specialization members
-that are used in a way that requires a definition shall be defined; the
-definitions of members of the primary template are never used as
-definitions for members of a class template partial specialization. An
-explicit specialization of a member of a class template partial
-specialization is declared in the same way as an explicit specialization
-of the primary template.
 [*Example 1*:
 ``` cpp
 // primary class template
@@ -2992,15 +2948,15 @@ int main() {
 — *end example*]
 If a member template of a class template is partially specialized, the
 member template partial specializations are member templates of the
 enclosing class template; if the enclosing class template is
-instantiated ([[temp.inst]], [[temp.explicit]]), a declaration for
-every member template partial specialization is also instantiated as
-part of creating the members of the class template specialization. If
-the primary member template is explicitly specialized for a given
-(implicit) specialization of the enclosing class template, the partial
 specializations of the member template are ignored for this
 specialization of the enclosing class template. If a partial
 specialization of the member template is explicitly specialized for a
 given (implicit) specialization of the enclosing class template, the
 primary member template and its other partial specializations are still
@@ -3023,28 +2979,33 @@ A<char>::B<int>  abci;                                          // uses #1
 — *end example*]
 ### Function templates <a id="temp.fct">[[temp.fct]]</a>
 A function template defines an unbounded set of related functions.
 [*Example 1*:
-A family of sort functions might be declared like this:
 ``` cpp
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 — *end example*]
-A function template can be overloaded with other function templates and
-with non-template functions [[dcl.fct]]. A non-template function is not
-related to a function template (i.e., it is never considered to be a
-specialization), even if it has the same name and type as a potentially
-generated function template specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
@@ -3079,17 +3040,17 @@ names of the template parameters are significant only for establishing
 the relationship between the template parameters and the rest of the
 signature.
 [*Note 1*:
-Two distinct function templates may have identical function return types
 and function parameter lists, even if overload resolution alone cannot
 distinguish them.
 ``` cpp
 template<class T> void f();
-template<int I> void f();       // OK: overloads the first template
                                 // distinguishable with an explicit template argument list
 ```
 — *end note*]
@@ -3126,25 +3087,27 @@ another token that names the same template parameter in the other
 expression. Two unevaluated operands that do not involve template
 parameters are considered equivalent if two function definitions
 containing the expressions would satisfy the one-definition rule, except
 that the tokens used to name types and declarations may differ as long
 as they name the same entities, and the tokens used to form concept-ids
-may differ as long as the two *template-id*s are the same [[temp.type]].
 [*Note 3*: For instance, `A<42>` and `A<40+2>` name the same
 type. — *end note*]
 Two *lambda-expression*s are never considered equivalent.
 [*Note 4*: The intent is to avoid *lambda-expression*s appearing in the
 signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
-only the name itself is considered, not the result of name lookup in the
-context of the template. If multiple declarations of the same function
-template differ in the result of this name lookup, the result for the
-first declaration is used.
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
@@ -3153,11 +3116,11 @@ template <int K, int L> void f(A<K+L>);         // same as #1
 template <class T> decltype(g(T())) h();
 int g(int);
 template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup…
   { return g(T()); }                            // …{} although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
-                                                // was not in scope at the first declaration of h()
 // ill-formed, no diagnostic required: the two expressions are functionally equivalent but not equivalent
 template <int N> void foo(const char (*s)[([]{}, N)]);
 template <int N> void foo(const char (*s)[([]{}, N)]);
@@ -3174,13 +3137,25 @@ of template arguments, the evaluation of the expression results in the
 same value. Two unevaluated operands that are not equivalent are
 functionally equivalent if, for any given set of template arguments, the
 expressions perform the same operations in the same order with the same
 entities.
-[*Note 5*: For instance, one could have redundant
 parentheses. — *end note*]
 Two *template-head*s are *equivalent* if their
 *template-parameter-list*s have the same length, corresponding
 *template-parameter*s are equivalent and are both declared with
 *type-constraint*s that are equivalent if either *template-parameter* is
 declared with a *type-constraint*, and if either *template-head* has a
@@ -3200,25 +3175,24 @@ When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
-Two function templates are *equivalent* if they are declared in the same
-scope, have the same name, have equivalent *template-head*s, and have
-return types, parameter lists, and trailing *requires-clause*s (if any)
-that are equivalent using the rules described above to compare
-expressions involving template parameters. Two function templates are
-*functionally equivalent* if they are declared in the same scope, have
-the same name, accept and are satisfied by the same set of template
-argument lists, and have return types and parameter lists that are
-functionally equivalent using the rules described above to compare
-expressions involving template parameters. If the validity or meaning of
-the program depends on whether two constructs are equivalent, and they
-are functionally equivalent but not equivalent, the program is
-ill-formed, no diagnostic required.
-[*Note 6*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
@@ -3240,24 +3214,23 @@ template <int I> void f(A<I>, A<I+1+2+3+4>);
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
-If a function template is overloaded, the use of a function template
-specialization might be ambiguous because template argument deduction
-[[temp.deduct]] may associate the function template specialization with
-more than one function template declaration. *Partial ordering* of
-overloaded function template declarations is used in the following
-contexts to select the function template to which a function template
-specialization refers:
 - during overload resolution for a call to a function template
   specialization [[over.match.best]];
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
-  specialization is selected to match a placement operator new (
-  [[basic.stc.dynamic.deallocation]], [[expr.new]]);
 - when a friend function declaration [[temp.friend]], an explicit
   instantiation [[temp.explicit]] or an explicit specialization
   [[temp.expl.spec]] refers to a function template specialization.
 Partial ordering selects which of two function templates is more
@@ -3407,12 +3380,12 @@ template<class T, class... U> void f(T, U...);          // #1
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
-  f(&i);                                                // OK: calls #2
-  g(&i);                                                // OK: calls #3
 }
 ```
 — *end example*]
@@ -3462,20 +3435,20 @@ template <typename T> concept C = True<T>;
 void f(C auto &, auto &) = delete;
 template <C Q> void f(Q &, C auto &);
 void g(struct A *ap, struct B *bp) {
-  f(*ap, *bp);                  // OK: Can use different methods to produce template parameters
 }
 template <typename T, typename U> struct X {};
 template <typename T, C U, typename V> bool operator==(X<T, U>, V) = delete;
 template <C T, C U, C V>               bool operator==(T, X<U, V>);
 void h() {
-  X<void *, int>{} == 0;        // OK: Correspondence of [T, U, V] and [U, V, T]
 }
 ```
 — *end example*]
@@ -3496,11 +3469,11 @@ it is equivalent to the associated type obtained by substitution of its
 [*Example 1*:
 ``` cpp
 template<class T> struct Alloc { ... };
 template<class T> using Vec = vector<T, Alloc<T>>;
-Vec<int> v;         // same as vector<int, Alloc<int>{> v;}
 template<class T>
   void process(Vec<T>& v)
   { ... }
@@ -3513,11 +3486,11 @@ template<template<class> class TT>
 f(v);               // error: Vec not deduced
 template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
-g(v);               // OK: TT = vector
 ```
 — *end example*]
 However, if the *template-id* is dependent, subsequent template argument
@@ -3569,20 +3542,21 @@ template <class T>
 A *concept* is a template that defines constraints on its template
 arguments.
 ``` bnf
 concept-definition:
-  concept concept-name '=' constraint-expression ';'
 ```
 ``` bnf
 concept-name:
   identifier
 ```
 A *concept-definition* declares a concept. Its *identifier* becomes a
-*concept-name* referring to that concept within its scope.
 [*Example 1*:
 ``` cpp
 template<typename T>
@@ -3598,83 +3572,133 @@ template<C T>       // C, as a type-constraint, constrains f2(T)
 T f2(T x) { return x; }
 ```
 — *end example*]
-A *concept-definition* shall appear at namespace scope
 [[basic.scope.namespace]].
 A concept shall not have associated constraints [[temp.constr.decl]].
 A concept is not instantiated [[temp.spec]].
 [*Note 1*: A concept-id [[temp.names]] is evaluated as an expression. A
 concept cannot be explicitly instantiated [[temp.explicit]], explicitly
-specialized [[temp.expl.spec]], or partially specialized. — *end note*]
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its
 *prototype parameter*. A *type concept* is a concept whose prototype
 parameter is a type *template-parameter*.
 ## Name resolution <a id="temp.res">[[temp.res]]</a>
-Three kinds of names can be used within a template definition:
-- The name of the template itself, and names declared within the
-  template itself.
-- Names dependent on a *template-parameter* [[temp.dep]].
-- Names from scopes which are visible within the template definition.
-A name used in a template declaration or definition and that is
-dependent on a *template-parameter* is assumed not to name a type unless
-the applicable name lookup finds a type name or the name is qualified by
-the keyword `typename`.
 [*Example 1*:
 ``` cpp
-// no B declared here
-class X;
-template<class T> class Y {
-  class Z; // forward declaration of member class
-  void f() {
-    X* a1;                      // declare pointer to X
-    T* a2;                      // declare pointer to T
-    Y* a3;                      // declare pointer to Y<T>
-    Z* a4;                      // declare pointer to Z
-    typedef typename T::A TA;
-    TA* a5;                     // declare pointer to T's A
-    typename T::A* a6;          // declare pointer to T's A
- T::A* a7;                   // error: no visible declaration of a7
- // T::A is not a type name; multiplication of T::A by a7
-    B* a8; // error: no visible declarations of B and a8
- // B is not a type name; multiplication of B by a8
 }
 };
 ```
 — *end example*]
 ``` bnf
 typename-specifier:
   typename nested-name-specifier identifier
   typename nested-name-specifier 'templateₒₚₜ ' simple-template-id
 ```
-A *typename-specifier* denotes the type or class template denoted by the
-*simple-type-specifier* [[dcl.type.simple]] formed by omitting the
-keyword `typename`. The usual qualified name lookup
-[[basic.lookup.qual]] is used to find the *qualified-id* even in the
-presence of `typename`.
-[*Example 2*:
 ``` cpp
 struct A {
   struct X { };
   int X;
@@ -3686,52 +3710,44 @@ template<class T> void f(T t) {
   typename T::X x;
 }
 void foo() {
   A a;
   B b;
-  f(b);             // OK: T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
 — *end example*]
-A qualified name used as the name in a *class-or-decltype*
-[[class.derived]] or an *elaborated-type-specifier* is implicitly
-assumed to name a type, without the use of the `typename` keyword. In a
-*nested-name-specifier* that immediately contains a
-*nested-name-specifier* that depends on a template parameter, the
-*identifier* or *simple-template-id* is implicitly assumed to name a
-type, without the use of the `typename` keyword.
-[*Note 1*: The `typename` keyword is not permitted by the syntax of
-these constructs. — *end note*]
-A *qualified-id* is assumed to name a type if
-- it is a qualified name in a type-id-only context (see below), or
-- it is a *decl-specifier* of the *decl-specifier-seq* of a
   - *simple-declaration* or a *function-definition* in namespace scope,
   - *member-declaration*,
-  - *parameter-declaration* in a *member-declaration* [^10], unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *declarator* of a function or function
     template declaration whose *declarator-id* is qualified, unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *lambda-declarator* or
     *requirement-parameter-list*, unless that *parameter-declaration*
     appears in a default argument, or
   - *parameter-declaration* of a (non-type) *template-parameter*.
-A qualified name is said to be in a *type-id-only context* if it appears
-in a *type-id*, *new-type-id*, or *defining-type-id* and the smallest
-enclosing *type-id*, *new-type-id*, or *defining-type-id* is a
-*new-type-id*, *defining-type-id*, *trailing-return-type*, default
-argument of a *type-parameter* of a template, or *type-id* of a
-`static_cast`, `const_cast`, `reinterpret_cast`, or `dynamic_cast`.
-[*Example 3*:
 ``` cpp
 template<class T> T::R f();             // OK, return type of a function declaration at global scope
 template<class T> void f(T::R);         // ill-formed, no diagnostic required: attempt to declare
                                         // a void variable template
@@ -3749,15 +3765,16 @@ template<typename T> void f() {
 }
 ```
 — *end example*]
-A *qualified-id* that refers to a member of an unknown specialization,
-that is not prefixed by `typename`, and that is not otherwise assumed to
-name a type (see above) denotes a non-type.
-[*Example 4*:
 ``` cpp
 template <class T> void f(int i) {
   T::x * i;         // expression, not the declaration of a variable i
 }
@@ -3776,63 +3793,53 @@ int main() {
 }
 ```
 — *end example*]
-Within the definition of a class template or within the definition of a
-member of a class template following the *declarator-id*, the keyword
-`typename` is not required when referring to a member of the current
-instantiation [[temp.dep.type]].
-[*Example 5*:
-``` cpp
-template<class T> struct A {
-  typedef int B;
-  B b;              // OK, no typename required
-};
-```
-— *end example*]
 The validity of a template may be checked prior to any instantiation.
-[*Note 2*: Knowing which names are type names allows the syntax of
 every template to be checked in this way. — *end note*]
 The program is ill-formed, no diagnostic required, if:
-- no valid specialization can be generated for a template or a
- substatement of a constexpr if statement [[stmt.if]] within a template
-  and the template is not instantiated, or
-- no substitution of template arguments into a *type-constraint* or
- *requires-clause* would result in a valid expression, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
 - a hypothetical instantiation of a template immediately following its
   definition would be ill-formed due to a construct that does not depend
   on a template parameter, or
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
   corresponding construct in any actual instantiation of the template.
-  \[*Note 3*:
 This can happen in situations including the following:
 - a type used in a non-dependent name is incomplete at the point at
   which a template is defined but is complete at the point at which an
   instantiation is performed, or
 - lookup for a name in the template definition found a
- *using-declaration*, but the lookup in the corresponding scope in
-    the instantiation does not find any declarations because the
- *using-declaration* was a pack expansion and the corresponding pack
-    is empty, or
- - an instantiation uses a default argument or default template
-    argument that had not been defined at the point at which the
-    template was defined, or
 - constant expression evaluation [[expr.const]] within the template
   instantiation uses
- - the value of a const object of integral or unscoped enumeration
-      type or
   - the value of a `constexpr` object or
   - the value of a reference or
   - the definition of a constexpr function,
   and that entity was not defined when the template was defined, or
@@ -3846,23 +3853,25 @@ The program is ill-formed, no diagnostic required, if:
 — *end note*]
 Otherwise, no diagnostic shall be issued for a template for which a
 valid specialization can be generated.
-[*Note 4*: If a template is instantiated, errors will be diagnosed
 according to the other rules in this document. Exactly when these errors
 are diagnosed is a quality of implementation issue. — *end note*]
-[*Example 6*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
     t = i;          // diagnosed if X::f is instantiated, and the assignment to t is an error
     p = i;          // may be diagnosed even if X::f is not instantiated
     p = j;          // may be diagnosed even if X::f is not instantiated
   }
   void g(T t) {
     +;              // may be diagnosed even if X::g is not instantiated
   }
 };
@@ -3874,79 +3883,11 @@ template<class... T> union X : T... { };            // error: union with base cl
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
 — *end example*]
-When looking for the declaration of a name used in a template
-definition, the usual lookup rules ([[basic.lookup.unqual]],
-[[basic.lookup.argdep]]) are used for non-dependent names. The lookup of
-names dependent on the template parameters is postponed until the actual
-template argument is known [[temp.dep]].
-[*Example 7*:
-``` cpp
-#include <iostream>
-using namespace std;
-template<class T> class Set {
-  T* p;
-  int cnt;
-public:
-  Set();
-  Set<T>(const Set<T>&);
-  void printall() {
-    for (int i = 0; i<cnt; i++)
-      cout << p[i] << '\n';
-  }
-};
-```
-In the example, `i` is the local variable `i` declared in `printall`,
-`cnt` is the member `cnt` declared in `Set`, and `cout` is the standard
-output stream declared in `iostream`. However, not every declaration can
-be found this way; the resolution of some names must be postponed until
-the actual *template-argument*s are known. For example, even though the
-name `operator<<` is known within the definition of `printall()` and a
-declaration of it can be found in `<iostream>`, the actual declaration
-of `operator<<` needed to print `p[i]` cannot be known until it is known
-what type `T` is [[temp.dep]].
-— *end example*]
-If a name does not depend on a *template-parameter* (as defined in
-[[temp.dep]]), a declaration (or set of declarations) for that name
-shall be in scope at the point where the name appears in the template
-definition; the name is bound to the declaration (or declarations) found
-at that point and this binding is not affected by declarations that are
-visible at the point of instantiation.
-[*Example 8*:
-``` cpp
-void f(char);
-template<class T> void g(T t) {
-  f(1);             // f(char)
-  f(T(1));          // dependent
-  f(t);             // dependent
-  dd++;             // not dependent; error: declaration for dd not found
-}
-enum E { e };
-void f(E);
-double dd;
-void h() {
-  g(e);             // will cause one call of f(char) followed by two calls of f(E)
-  g('a');           // will cause three calls of f(char)
-}
-```
-— *end example*]
-[*Note 5*: For purposes of name lookup, default arguments and
 *noexcept-specifier*s of function templates and default arguments and
 *noexcept-specifier*s of member functions of class templates are
 considered definitions [[temp.decls]]. — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
@@ -3957,18 +3898,18 @@ as a *template-name* or a *type-name*. When it is used with a
 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
-followed by the *template-parameter*s of the class template enclosed in
-`<>`.
-Within the scope of a class template specialization or partial
-specialization, when the injected-class-name is used as a *type-name*,
-it is equivalent to the *template-name* followed by the
-*template-argument*s of the class template specialization or partial
-specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
@@ -3985,11 +3926,11 @@ template<> class Y<int> {
 — *end example*]
 The injected-class-name of a class template or class template
 specialization can be used as either a *template-name* or a *type-name*
-wherever it is in scope.
 [*Example 2*:
 ``` cpp
 template <class T> struct Base {
@@ -3998,12 +3939,12 @@ template <class T> struct Base {
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
-template<class T, template<class> class U = T::template Base> struct Third { };
-Third<Derived<int> > t;                 // OK: default argument uses injected-class-name as a template
 ```
 — *end example*]
 A lookup that finds an injected-class-name [[class.member.lookup]] can
@@ -4041,135 +3982,105 @@ template<class T> class X {
 };
 ```
 — *end example*]
-The name of a *template-parameter* shall not be redeclared within its
-scope (including nested scopes). A *template-parameter* shall not have
-the same name as the template name.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
-  int T;                                // error: template-parameter redeclared
   void f() {
-    char T;                             // error: template-parameter redeclared
   }
 };
-template<class X> class X;              // error: template-parameter redeclared
 ```
 — *end example*]
-In the definition of a member of a class template that appears outside
-of the class template definition, the name of a member of the class
-template hides the name of a *template-parameter* of any enclosing class
-templates (but not a *template-parameter* of the member if the member is
-a class or function template).
 [*Example 6*:
 ``` cpp
-template<class T> struct A {
-  struct B { ... };
     typedef void C;
     void f();
     template<class U> void g(U);
   };
-template<class B> void A<B>::f() {
-  B b;              // A's B, not the template parameter
 }
-template<class B> template<class C> void A<B>::g(C) {
- B b; // A's B, not the template parameter
-  C c;              // the template parameter C, not A's C
 }
-```
-— *end example*]
-In the definition of a member of a class template that appears outside
-of the namespace containing the class template definition, the name of a
-*template-parameter* hides the name of a member of this namespace.
-[*Example 7*:
-``` cpp
-namespace N {
-  class C { };
-  template<class T> class B {
-    void f(T);
-  };
-}
-template<class C> void N::B<C>::f(C) {
-  C b;              // C is the template parameter, not N::C
 }
 ```
 — *end example*]
-In the definition of a class template or in the definition of a member
-of such a template that appears outside of the template definition, for
-each non-dependent base class [[temp.dep.type]], if the name of the base
-class or the name of a member of the base class is the same as the name
-of a *template-parameter*, the base class name or member name hides the
-*template-parameter* name [[basic.scope.hiding]].
-[*Example 8*:
-``` cpp
-struct A {
-  struct B { ... };
-  int a;
-  int Y;
-};
-template<class B, class a> struct X : A {
-  B b;              // A's B
-  a b;              // error: A's a isn't a type name
-};
-```
-— *end example*]
 ### Dependent names <a id="temp.dep">[[temp.dep]]</a>
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
 names. An expression may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
 when evaluated as a constant expression [[expr.const]] may depend on a
-template parameter) as described in this subclause.
-In an expression of the form:
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
-where the *postfix-expression* is an *unqualified-id*, the
-*unqualified-id* denotes a *dependent name* if
 - any of the expressions in the *expression-list* is a pack expansion
-  [[temp.variadic]],
 - any of the expressions or *braced-init-list*s in the *expression-list*
   is type-dependent [[temp.dep.expr]], or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
-If an operand of an operator is a type-dependent expression, the
-operator also denotes a dependent name.
-[*Note 1*: Such names are unbound and are looked up at the point of the
-template instantiation [[temp.point]] in both the context of the
-template definition and the context of the point of instantiation
 [[temp.dep.candidate]]. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -4185,88 +4096,30 @@ template<class T> struct X : B<T> {
 The base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
-In the definition of a class or class template, the scope of a dependent
-base class [[temp.dep.type]] is not examined during unqualified name
-lookup either at the point of definition of the class template or member
-or during an instantiation of the class template or member.
-[*Example 2*:
-``` cpp
-typedef double A;
-template<class T> class B {
-  typedef int A;
-};
-template<class T> struct X : B<T> {
-  A a;              // a has type double
-};
-```
-The type name `A` in the definition of `X<T>` binds to the typedef name
-defined in the global namespace scope, not to the typedef name defined
-in the base class `B<T>`.
-— *end example*]
-[*Example 3*:
-``` cpp
-struct A {
-  struct B { ... };
-  int a;
-  int Y;
-};
-int a;
-template<class T> struct Y : T {
-  struct B { ... };
-  B b;                          // The B defined in Y
-  void f(int i) { a = i; }      // ::a
-  Y* p;                         // Y<T>
-};
-Y<A> ya;
-```
-The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
-not affect the binding of names in `Y<A>`.
-— *end example*]
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</a>
-A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
   of a class template, the injected-class-name [[class.pre]] of the
   class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
-  template argument list of the primary template (as described below)
- enclosed in `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
   or
-- in the definition of a partial specialization or a member of a partial
- specialization, the name of the class template followed by the
-  template argument list of the partial specialization enclosed in `<>`
- (or an equivalent template alias specialization). If the nᵗʰ template
- parameter is a template parameter pack, the nᵗʰ template argument is a
-  pack expansion [[temp.variadic]] whose pattern is the name of the
-  template parameter pack.
-The template argument list of a primary template is a template argument
-list in which the nᵗʰ template argument has the value of the nᵗʰ
-template parameter of the class template. If the nᵗʰ template parameter
-is a template parameter pack [[temp.variadic]], the nᵗʰ template
-argument is a pack expansion [[temp.variadic]] whose pattern is the name
-of the template parameter pack.
 A template argument that is equivalent to a template parameter can be
 used in place of that template parameter in a reference to the current
 instantiation. For a template *type-parameter*, a template argument is
 equivalent to a template parameter if it denotes the same type. For a
@@ -4348,32 +4201,17 @@ template<class T> struct A<T>::B::C : A<T> {
 — *end example*]
 — *end note*]
-A name is a *member of the current instantiation* if it is
-- An unqualified name that, when looked up, refers to at least one
- member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 3*: This can only occur when looking up a
- name in a scope enclosed by the definition of a class
-  template. — *end note*]
-- A *qualified-id* in which the *nested-name-specifier* refers to the
-  current instantiation and that, when looked up, refers to at least one
-  member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 4*: If no such member is found, and the
-  current instantiation has any dependent base classes, then the
-  *qualified-id* is a member of an unknown specialization; see
-  below. — *end note*]
-- An *id-expression* denoting the member in a class member access
-  expression [[expr.ref]] for which the type of the object expression is
-  the current instantiation, and the *id-expression*, when looked up
-  [[basic.lookup.classref]], refers to at least one member of a class
-  that is the current instantiation or a non-dependent base class
-  thereof. \[*Note 5*: If no such member is found, and the current
-  instantiation has any dependent base classes, then the *id-expression*
-  is a member of an unknown specialization; see below. — *end note*]
 [*Example 3*:
 ``` cpp
 template <class T> class A {
@@ -4389,66 +4227,51 @@ template <class T> int A<T>::f() {
 }
 ```
 — *end example*]
-A name is a *dependent member of the current instantiation* if it is a
-member of the current instantiation that, when looked up, refers to at
-least one member of a class that is the current instantiation.
-A name is a *member of an unknown specialization* if it is
-- A *qualified-id* in which the *nested-name-specifier* names a
-  dependent type that is not the current instantiation.
-- A *qualified-id* in which the *nested-name-specifier* refers to the
- current instantiation, the current instantiation has at least one
-  dependent base class, and name lookup of the *qualified-id* does not
- find any member of a class that is the current instantiation or a
-  non-dependent base class thereof.
-- An *id-expression* denoting the member in a class member access
- expression [[expr.ref]] in which either
-  - the type of the object expression is the current instantiation, the
-    current instantiation has at least one dependent base class, and
-    name lookup of the *id-expression* does not find a member of a class
-    that is the current instantiation or a non-dependent base class
-    thereof; or
-  - the type of the object expression is not the current instantiation
-    and the object expression is type-dependent.
-If a *qualified-id* in which the *nested-name-specifier* refers to the
-current instantiation is not a member of the current instantiation or a
-member of an unknown specialization, the program is ill-formed even if
-the template containing the *qualified-id* is not instantiated; no
-diagnostic required. Similarly, if the *id-expression* in a class member
-access expression for which the type of the object expression is the
-current instantiation does not refer to a member of the current
-instantiation or a member of an unknown specialization, the program is
-ill-formed even if the template containing the member access expression
-is not instantiated; no diagnostic required.
 [*Example 4*:
 ``` cpp
-template<class T> class A {
- typedef int type;
- void f() {
-    A<T>::type i;               // OK: refers to a member of the current instantiation
-    typename A<T>::other j;     // error: neither a member of the current instantiation nor
-                                // a member of an unknown specialization
-  }
 };
 ```
 — *end example*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
-instantiation with a *qualified-id* or class member access expression,
-the name in the *qualified-id* or class member access expression is
-looked up in the template instantiation context. If the result of this
-lookup differs from the result of name lookup in the template definition
-context, name lookup is ambiguous.
 [*Example 5*:
 ``` cpp
 struct A {
@@ -4464,84 +4287,87 @@ struct C : A, T {
   int f() { return this->m; }   // finds A::m in the template definition context
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
-template int C<B>::g();         // OK: transformation to class member access syntax
-                                // does not occur in the template definition context; see~[class.mfct.non-static]
 ```
 — *end example*]
 A type is dependent if it is
 - a template parameter,
-- a member of an unknown specialization,
-- a nested class or enumeration that is a dependent member of the
-  current instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose exception specification is value-dependent,
 - denoted by a *simple-template-id* in which either the template name is
   a template parameter or any of the template arguments is a dependent
   type or an expression that is type-dependent or value-dependent or is
-  a pack expansion \[*Note 6*: This includes an injected-class-name
-  [[class.pre]] of a class template used without a
-  *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
   type-dependent [[temp.dep.expr]].
-[*Note 7*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
-`this`
-is type-dependent if the class type of the enclosing member function is
 dependent [[temp.dep.type]].
-An *id-expression* is type-dependent if it is not a concept-id and it
-contains
-- an *identifier* associated by name lookup with one or more
- declarations declared with a dependent type,
-- an *identifier* associated by name lookup with a non-type
- *template-parameter* declared with a type that contains a placeholder
- type [[dcl.spec.auto]],
-- an *identifier* associated by name lookup with a variable declared
- with a type that contains a placeholder type [[dcl.spec.auto]] where
-  the initializer is type-dependent,
-- an *identifier* associated by name lookup with one or more
-  declarations of member functions of the current instantiation declared
-  with a return type that contains a placeholder type,
-- an *identifier* associated by name lookup with a structured binding
-  declaration [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
   type-dependent,
 - the *identifier* `__func__` [[dcl.fct.def.general]], where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
-- a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
-- a *nested-name-specifier* or a *qualified-id* that names a member of
-  an unknown specialization;
 or if it names a dependent member of the current instantiation that is a
 static data member of type “array of unknown bound of `T`” for some `T`
 [[temp.static]]. Expressions of the following forms are type-dependent
-only if the type specified by the *type-id*, *simple-type-specifier* or
-*new-type-id* is dependent, even if any subexpression is type-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
 '::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
 '::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
 dynamic_cast '<' type-id '>' '(' expression ')'
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
@@ -4568,21 +4394,19 @@ noexcept '(' expression ')'
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 A class member access expression [[expr.ref]] is type-dependent if the
 expression refers to a member of the current instantiation and the type
-of the referenced member is dependent, or the class member access
-expression refers to a member of an unknown specialization.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to a
 dependent type that is not the current instantiation, the type of `y` is
-always dependent. If `x` or `xp` refers to a non-dependent type or
-refers to the current instantiation, the type of `y` is the type of the
-class member access expression. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
@@ -4659,38 +4483,12 @@ the constant expression it specifies is value-dependent.
 Furthermore, a non-type *template-argument* is dependent if the
 corresponding non-type *template-parameter* is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
-A template *template-argument* is dependent if it names a
-*template-parameter* or is a *qualified-id* that refers to a member of
-an unknown specialization.
-### Non-dependent names <a id="temp.nondep">[[temp.nondep]]</a>
-Non-dependent names used in a template definition are found using the
-usual name lookup and bound at the point they are used.
-[*Example 1*:
-``` cpp
-void g(double);
-void h();
-template<class T> class Z {
-public:
-  void f() {
-    g(1);           // calls g(double)
-    h++;            // ill-formed: cannot increment function; this could be diagnosed
-                    // either here or at the point of instantiation
-  }
-};
-void g(int);        // not in scope at the point of the template definition, not considered for the call g(1)
-```
-— *end example*]
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
@@ -4762,26 +4560,17 @@ If two different points of instantiation give a template specialization
 different meanings according to the one-definition rule
 [[basic.def.odr]], the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
-For a function call where the *postfix-expression* is a dependent name,
-the candidate functions are found using the usual lookup rules from the
-template definition context ([[basic.lookup.unqual]],
-[[basic.lookup.argdep]]).
-[*Note 1*: For the part of the lookup using associated namespaces
-[[basic.lookup.argdep]], function declarations found in the template
-instantiation context are found by this lookup, as described in
-[[basic.lookup.argdep]]. — *end note*]
-If the call would be ill-formed or would find a better match had the
-lookup within the associated namespaces considered all the function
-declarations with external linkage introduced in those namespaces in all
-translation units, not just considering those declarations found in the
-template definition and template instantiation contexts, then the
-program has undefined behavior.
 [*Example 1*:
 Source file \`"X.h"\`
@@ -4881,11 +4670,11 @@ Module interface unit of \`M\`
 module;
 #include "X.h"
 export module M;
 import F;
 void g(X x) {
-  f(x);             // OK: instantiates f from F,
                     // operator+ is visible in instantiation context
 }
 ```
 — *end example*]
@@ -4977,43 +4766,14 @@ void k() {
 }
 ```
 — *end example*]
-### Friend names declared within a class template <a id="temp.inject">[[temp.inject]]</a>
-Friend classes or functions can be declared within a class template.
-When a template is instantiated, the names of its friends are treated as
-if the specialization had been explicitly declared at its point of
-instantiation.
-As with non-template classes, the names of namespace-scope friend
-functions of a class template specialization are not visible during an
-ordinary lookup unless explicitly declared at namespace scope
-[[class.friend]]. Such names may be found under the rules for associated
-classes [[basic.lookup.argdep]].[^11]
-[*Example 1*:
-``` cpp
-template<typename T> struct number {
-  number(int);
-  friend number gcd(number x, number y) { return 0; };
-};
-void g() {
-  number<double> a(3), b(4);
-  a = gcd(a,b);     // finds gcd because number<double> is an associated class,
-                    // making gcd visible in its namespace (global scope)
-  b = gcd(3,4);     // error: gcd is not visible
-}
-```
-— *end example*]
 ## Template instantiation and specialization <a id="temp.spec">[[temp.spec]]</a>
 The act of instantiating a function, a variable, a class, a member of a
 class template, or a member template is referred to as *template
 instantiation*.
 A function instantiated from a function template is called an
@@ -5032,16 +4792,16 @@ instantiated static data member.
 An explicit specialization may be declared for a function template, a
 variable template, a class template, a member of a class template, or a
 member template. An explicit specialization declaration is introduced by
 `template<>`. In an explicit specialization declaration for a variable
-template, a class template, a member of a class template or a class
-member template, the name of the variable or class that is explicitly
-specialized shall be a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
-template, the name of the function or member function explicitly
-specialized may be a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct A {
@@ -5077,23 +4837,24 @@ For a given template and a given set of *template-argument*s,
   program,
 - an explicit specialization shall be defined at most once in a program,
   as specified in [[basic.def.odr]], and
 - both an explicit instantiation and a declaration of an explicit
   specialization shall not appear in a program unless the explicit
- instantiation follows a declaration of the explicit specialization.
-An implementation is not required to diagnose a violation of this rule.
 The usual access checking rules do not apply to names in a declaration
 of an explicit instantiation or explicit specialization, with the
 exception of names appearing in a function body, default argument,
-base-clause, member-specification, enumerator-list, or static data
 member or variable template initializer.
 [*Note 1*: In particular, the template arguments and names used in the
 function declarator (including parameter types, return types and
-exception specifications) may be private types or objects that would
 normally not be accessible. — *end note*]
 Each class template specialization instantiated from a template has its
 own copy of any static members.
@@ -5179,13 +4940,14 @@ void g(D<int>* p, D<char>* pp, D<double>* ppp) {
 }
 ```
 — *end example*]
-If a class template has been declared, but not defined, at the point of
-instantiation [[temp.point]], the instantiation yields an incomplete
-class type [[basic.types]].
 [*Example 2*:
 ``` cpp
 template<class T> class X;
@@ -5231,21 +4993,21 @@ template<> void C<int>::g() { } // error: redefinition of C<int>::g
 — *end example*]
 However, for the purpose of determining whether an instantiated
 redeclaration is valid according to  [[basic.def.odr]] and
-[[class.mem]], a declaration that corresponds to a definition in the
-template is considered to be a definition.
 [*Example 4*:
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
   template<class Y> struct Inner<T, Y>;         // #1a
-  template<class Y> struct Inner<T, Y> { };     // #1b; OK: valid redeclaration of #1a
   template<class Y> struct Inner<U, Y> { };     // #2
 };
 Outer<int, int> outer;                          // error at #2
 ```
@@ -5264,19 +5026,18 @@ Friendly<char> fc;
 Friendly<float> ff;                             // error: produces second definition of f(U)
 ```
 — *end example*]
-Unless a member of a class template or a member template is a declared
-specialization, the specialization of the member is implicitly
-instantiated when the specialization is referenced in a context that
-requires the member definition to exist or if the existence of the
-definition of the member affects the semantics of the program; in
-particular, the initialization (and any associated side effects) of a
-static data member does not occur unless the static data member is
-itself used in a way that requires the definition of the static data
-member to exist.
 Unless a function template specialization is a declared specialization,
 the function template specialization is implicitly instantiated when the
 specialization is referenced in a context that requires a function
 definition to exist or if the existence of the definition affects the
@@ -5291,11 +5052,11 @@ template is implicitly instantiated when the function is called in a
 context that requires the value of the default argument.
 [*Note 4*: An inline function that is the subject of an explicit
 instantiation declaration is not a declared specialization; the intent
 is that it still be implicitly instantiated when odr-used
-[[basic.def.odr]] so that the body can be considered for inlining, but
 that no out-of-line copy of it be generated in the translation
 unit. — *end note*]
 [*Example 5*:
@@ -5379,11 +5140,11 @@ If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated [[temp.over]].
 An implementation shall not implicitly instantiate a function template,
 a variable template, a member template, a non-virtual member function, a
-member class, a static data member of a class template, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
 instantiation is required.
 [*Note 5*: The instantiation of a generic lambda does not require
 instantiation of substatements of a constexpr if statement within its
@@ -5391,67 +5152,36 @@ instantiation of substatements of a constexpr if statement within its
 instantiated. — *end note*]
 It is unspecified whether or not an implementation implicitly
 instantiates a virtual member function of a class template if the
 virtual member function would not otherwise be instantiated. The use of
-a template specialization in a default argument shall not cause the
-template to be implicitly instantiated except that a class template may
-be instantiated where its complete type is needed to determine the
-correctness of the default argument. The use of a default argument in a
 function call causes specializations in the default argument to be
-implicitly instantiated.
-Implicitly instantiated class, function, and variable template
-specializations are placed in the namespace where the template is
-defined. Implicitly instantiated specializations for members of a class
-template are placed in the namespace where the enclosing class template
-is defined. Implicitly instantiated member templates are placed in the
-namespace where the enclosing class or class template is defined.
-[*Example 8*:
-``` cpp
-namespace N {
-  template<class T> class List {
-  public:
-    T* get();
-  };
-}
-template<class K, class V> class Map {
-public:
-  N::List<V> lt;
-  V get(K);
-};
-void g(Map<const char*,int>& m) {
-  int i = m.get("Nicholas");
-}
-```
-A call of `lt.get()` from `Map<const char*,int>::get()` would place
-`List<int>::get()` in the namespace `N` rather than in the global
-namespace.
-— *end example*]
-If a function template `f` is called in a way that requires a default
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
 function template `f` used at that point, except that the scope in which
-a closure type is declared [[expr.prim.lambda.closure]] – and therefore
-its associated namespaces – remain as determined from the context of the
 definition for the default argument. This analysis is called *default
 argument instantiation*. The instantiated default argument is then used
 as the argument of `f`.
 Each default argument is instantiated independently.
-[*Example 9*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
@@ -5482,11 +5212,11 @@ template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
 on the total depth of recursive instantiations [[implimits]], which
 could involve more than one template. The result of an infinite
 recursion in instantiation is undefined.
-[*Example 10*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
@@ -5508,11 +5238,11 @@ declarations.
 [*Note 7*: The satisfaction of constraints is determined during
 template argument deduction [[temp.deduct]] and overload resolution
 [[over.match]]. — *end note*]
-[*Example 11*:
 ``` cpp
 template<typename T> concept C = sizeof(T) > 2;
 template<typename T> concept D = C<T> && sizeof(T) > 4;
@@ -5530,11 +5260,11 @@ specialization. Their constraints are not satisfied, and they suppress
 the implicit declaration of a default constructor for `S<char>`
 [[class.default.ctor]], so there is no viable constructor for `s1`.
 — *end example*]
-[*Example 12*:
 ``` cpp
 template<typename T> struct S1 {
   template<typename U>
     requires false
@@ -5584,33 +5314,12 @@ appertain to an explicit instantiation.
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
 *simple-template-id*; otherwise, the *declaration* shall be a
 *simple-declaration* whose *init-declarator-list* comprises a single
 *init-declarator* that does not have an *initializer*. If the explicit
-instantiation is for a function or member function, the *unqualified-id*
-in the *declarator* shall be either a *template-id* or, where all
-template arguments can be deduced, a *template-name* or
-*operator-function-id*.
-[*Note 1*: The declaration may declare a *qualified-id*, in which case
-the *unqualified-id* of the *qualified-id* must be a
-*template-id*. — *end note*]
-If the explicit instantiation is for a member function, a member class
-or a static data member of a class template specialization, the name of
-the class template specialization in the *qualified-id* for the member
-name shall be a *simple-template-id*. If the explicit instantiation is
-for a variable template specialization, the *unqualified-id* in the
-*declarator* shall be a *simple-template-id*. An explicit instantiation
-shall appear in an enclosing namespace of its template. If the name
-declared in the explicit instantiation is an unqualified name, the
-explicit instantiation shall appear in the namespace where its template
-is declared or, if that namespace is inline [[namespace.def]], any
-namespace from its enclosing namespace set.
-[*Note 2*: Regarding qualified names in declarators, see
-[[dcl.meaning]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<class T> class Array { void mf(); };
@@ -5626,26 +5335,28 @@ namespace N {
 template void N::f<int>(int&);
 ```
 — *end example*]
-A declaration of a function template, a variable template, a member
-function or static data member of a class template, or a member function
-template of a class or class template shall precede an explicit
-instantiation of that entity. A definition of a class template, a member
-class of a class template, or a member class template of a class or
-class template shall precede an explicit instantiation of that entity
-unless the explicit instantiation is preceded by an explicit
-specialization of the entity with the same template arguments. If the
-*declaration* of the explicit instantiation names an implicitly-declared
-special member function [[special]], the program is ill-formed.
 The *declaration* in an *explicit-instantiation* and the *declaration*
 produced by the corresponding substitution into the templated function,
 variable, or class are two declarations of the same entity.
-[*Note 3*:
 These declarations are required to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
@@ -5679,41 +5390,17 @@ that template, the explicit instantiation has no effect. Otherwise, for
 an explicit instantiation definition, the definition of a function
 template, a variable template, a member function template, or a member
 function or static data member of a class template shall be present in
 every translation unit in which it is explicitly instantiated.
-An explicit instantiation of a class, function template, or variable
-template specialization is placed in the namespace in which the template
-is defined. An explicit instantiation for a member of a class template
-is placed in the namespace where the enclosing class template is
-defined. An explicit instantiation for a member template is placed in
-the namespace where the enclosing class or class template is defined.
-[*Example 3*:
-``` cpp
-namespace N {
-  template<class T> class Y { void mf() { } };
-}
-template class Y<int>;          // error: class template Y not visible in the global namespace
-using N::Y;
-template class Y<int>;          // error: explicit instantiation outside of the namespace of the template
-template class N::Y<char*>;             // OK: explicit instantiation in namespace N
-template void N::Y<double>::mf();       // OK: explicit instantiation in namespace N
-```
-— *end example*]
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
-function template specialization provided it can be deduced from the
-type of a function parameter [[temp.deduct]].
-[*Example 4*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
@@ -5721,50 +5408,49 @@ template<class T> void sort(Array<T>& v) { ... }
 template void sort<>(Array<int>&);
 ```
 — *end example*]
-[*Note 4*: An explicit instantiation of a constrained template is
 required to satisfy that template’s associated constraints
 [[temp.constr.decl]]. The satisfaction of constraints is determined when
 forming the template name of an explicit instantiation in which all
 template arguments are specified [[temp.names]], or, for explicit
 instantiations of function templates, during template argument deduction
 [[temp.deduct.decl]] when one or more trailing template arguments are
 left unspecified. — *end note*]
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
-definition) of each of its members (not including members inherited from
-base classes and members that are templates) that has not been
 previously explicitly specialized in the translation unit containing the
 explicit instantiation, provided that the associated constraints, if
 any, of that member are satisfied by the template arguments of the
-explicit instantiation ([[temp.constr.decl]], [[temp.constr.constr]]),
 except as described below.
-[*Note 5*: In addition, it will typically be an explicit instantiation
 of certain implementation-dependent data about the class. — *end note*]
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
 An explicit instantiation of a prospective destructor [[class.dtor]]
-shall name the selected destructor of the class.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
 also used in a way that would otherwise cause an implicit instantiation
 [[temp.inst]] in the translation unit shall be the subject of an
 explicit instantiation definition somewhere in the program; otherwise
 the program is ill-formed, no diagnostic required.
-[*Note 6*: This rule does apply to inline functions even though an
 explicit instantiation declaration of such an entity has no other
 normative effect. This is needed to ensure that if the address of an
 inline function is taken in a translation unit in which the
 implementation chose to suppress the out-of-line body, another
 translation unit will supply the body. — *end note*]
@@ -5773,11 +5459,11 @@ An explicit instantiation declaration shall not name a specialization of
 a template with internal linkage.
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
-[*Example 5*:
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
@@ -5826,65 +5512,67 @@ specializations instantiated from the class template. Similarly,
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
 — *end example*]
-An explicit specialization shall not use a *storage-class-specifier*
-[[dcl.stc]] other than `thread_local`.
 An explicit specialization may be declared in any scope in which the
-corresponding primary template may be defined ([[namespace.memdef]],
-[[class.mem]], [[temp.mem]]).
-A declaration of a function template, class template, or variable
-template being explicitly specialized shall precede the declaration of
-the explicit specialization.
 [*Note 1*: A declaration, but not a definition of the template is
 required. — *end note*]
-The definition of a class or class template shall precede the
 declaration of an explicit specialization for a member template of the
 class or class template.
 [*Example 2*:
 ``` cpp
 template<> class X<int> { ... };          // error: X not a template
 template<class T> class X;
-template<> class X<char*> { ... };        // OK: X is a template
 ```
 — *end example*]
 A member function, a member function template, a member class, a member
 enumeration, a member class template, a static data member, or a static
 data member template of a class template may be explicitly specialized
 for a class specialization that is implicitly instantiated; in this
-case, the definition of the class template shall precede the explicit
-specialization for the member of the class template. If such an explicit
-specialization for the member of a class template names an
 implicitly-declared special member function [[special]], the program is
 ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
-explicitly defined if its definition is required. In this case, the
-definition of the class template explicit specialization shall be in
-scope at the point at which the member is defined. The definition of an
-explicitly specialized class is unrelated to the definition of a
-generated specialization. That is, its members need not have the same
-names, types, etc. as the members of a generated specialization. Members
-of an explicitly specialized class template are defined in the same
-manner as members of normal classes, and not using the `template<>`
-syntax. The same is true when defining a member of an explicitly
-specialized member class. However, `template<>` is used in defining a
-member of an explicitly specialized member class template that is
-specialized as a class template.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
@@ -5930,20 +5618,20 @@ template<class U> void A<short>::C<U>::f() { ... }    // error: template<> requi
 ```
 — *end example*]
 If a template, a member template or a member of a class template is
-explicitly specialized then that specialization shall be declared before
-the first use of that specialization that would cause an implicit
-instantiation to take place, in every translation unit in which such a
-use occurs; no diagnostic is required. If the program does not provide a
-definition for an explicit specialization and either the specialization
-is used in a way that would cause an implicit instantiation to take
-place or the member is a virtual member function, the program is
-ill-formed, no diagnostic required. An implicit instantiation is never
-generated for an explicit specialization that is declared but not
-defined.
 [*Example 4*:
 ``` cpp
 class String { };
@@ -5953,11 +5641,11 @@ template<class T> void sort(Array<T>& v) { ... }
 void f(Array<String>& v) {
   sort(v);          // use primary template sort(Array<T>&), T is String
 }
 template<> void sort<String>(Array<String>& v);     // error: specialization after use of primary template
-template<> void sort<>(Array<char*>& v);            // OK: sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
 template<> enum A<int>::E : int { eint };           // OK
@@ -5988,52 +5676,32 @@ can affect whether a program is well-formed according to the relative
 positioning of the explicit specialization declarations and their points
 of instantiation in the translation unit as specified above and below.
 When writing a specialization, be careful about its location; or to make
 it compile will be such a trial as to kindle its self-immolation.
-A template explicit specialization is in the scope of the namespace in
-which the template was defined.
-[*Example 5*:
-``` cpp
-namespace N {
-  template<class T> class X { ... };
-  template<class T> class Y { ... };
-  template<> class X<int> { ... };        // OK: specialization in same namespace
-  template<> class Y<double>;                   // forward-declare intent to specialize for double
-}
-template<> class N::Y<double> { ... };    // OK: specialization in enclosing namespace
-template<> class N::Y<short> { ... };     // OK: specialization in enclosing namespace
-```
-— *end example*]
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes
 [[basic.types]].
-[*Example 6*:
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> class X<int>;
-X<int>* p;                                      // OK: pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
-provided it can be deduced from the function argument type.
-[*Example 7*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v);
@@ -6056,22 +5724,29 @@ arguments are left unspecified. — *end note*]
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
 specialization [[temp.fct]].
 Whether an explicit specialization of a function or variable template is
-inline, constexpr, or an immediate function is determined by the
-explicit specialization and is independent of those properties of the
-template.
-[*Example 8*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
-template<> inline void f<>(int) { ... }   // OK: inline
-template<> int g<>(int) { ... }           // OK: not inline
 ```
 — *end example*]
 An explicit specialization of a static data member of a template or an
@@ -6079,28 +5754,29 @@ explicit specialization of a static data member template is a definition
 if the declaration includes an initializer; otherwise, it is a
 declaration.
 [*Note 3*:
-The definition of a static data member of a template that requires
-default-initialization must use a *braced-init-list*:
 ``` cpp
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
-template<> X Q<int>::x { }; // definition
 ```
 — *end note*]
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
-[*Example 9*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
@@ -6132,11 +5808,11 @@ template<> void A<int>::h(int) { }
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
-[*Example 10*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
@@ -6158,11 +5834,11 @@ declaration, the keyword `template` followed by a
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
 types of the *template-parameter*s in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
-[*Example 11*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
@@ -6195,16 +5871,18 @@ definition for one of the following explicit specializations:
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
   specialization belongs is implicitly instantiated. \[*Note 4*: Default
-  function arguments may be specified in the declaration or definition
   of a member function of a class template specialization that is
   explicitly specialized. — *end note*]
 ## 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
@@ -6262,12 +5940,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,
@@ -6277,20 +5954,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);
@@ -6306,11 +5982,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:
@@ -6349,11 +6025,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
@@ -6368,11 +6044,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*]
@@ -6392,10 +6068,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.
@@ -6490,45 +6168,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(...) { }
@@ -6547,38 +6270,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(...);
@@ -6607,11 +6329,11 @@ j(0);               // deduction fails on #1, calls #2
 — *end example*]
 — *end note*]
-[*Example 7*:
 ``` cpp
 struct X { };
 struct Y {
   Y(X) {}
@@ -6624,30 +6346,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);
   ```
@@ -6658,17 +6380,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;
   };
@@ -6688,44 +6410,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
@@ -6911,15 +6635,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
@@ -6978,62 +6704,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.
@@ -7051,26 +6748,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.
@@ -7092,11 +6787,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.
@@ -7237,12 +6932,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.
@@ -7315,14 +7010,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
@@ -7334,13 +7029,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
@@ -7370,49 +7084,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
@@ -7456,11 +7171,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*:
@@ -7563,23 +7278,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
@@ -7587,28 +7319,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>);
@@ -7623,11 +7355,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
@@ -7647,13 +7379,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() {
@@ -7664,20 +7399,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);
@@ -7685,38 +7420,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 { };
@@ -7724,15 +7459,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 { };
@@ -7742,11 +7477,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
 ```
@@ -7758,12 +7493,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]].
@@ -7773,29 +7508,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; }
@@ -7812,11 +7548,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*:
@@ -7866,46 +7602,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
@@ -7914,11 +7646,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
@@ -7928,106 +7659,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.
@@ -8041,51 +7785,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

   primary-expression
   constraint-logical-and-expression '&&' primary-expression
 ```
 [*Note 1*: The `>` token following the *template-parameter-list* of a
+*template-declaration* can be the product of replacing a `>>` token by
 two consecutive `>` tokens [[temp.names]]. — *end note*]
 The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
 };
 ```
 — *end example*]
+[*Note 2*: A *template-declaration* can appear only as a namespace
+scope or class scope declaration. — *end note*]
+Its *declaration* shall not be an *export-declaration*. In a function
+template declaration, the *unqualified-id* of the *declarator-id* shall
+be a name.
+[*Note 3*: A class or variable template declaration of a
+*simple-template-id* declares a partial specialization
+[[temp.spec.partial]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
 instantiation the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
+A specialization (explicit or implicit) of one template is distinct from
+all specializations of any other template. A template, an explicit
+specialization [[temp.expl.spec]], and a partial specialization shall
+not have C language linkage.
+[*Note 4*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
+of template instantiation [[temp.decls]] and must obey the
+one-definition rule [[basic.def.odr]]. — *end note*]
+[*Note 5*: A template cannot have the same name as any other name bound
+in the same scope [[basic.scope.scope]], except that a function template
+can share a name with non-template functions [[dcl.fct]] and/or function
+templates [[temp.over]]. Specializations, including partial
+specializations [[temp.spec.partial]], do not reintroduce or bind names.
+Their target scope is the target scope of the primary template, so all
+specializations of a template belong to the same scope as it
+does. — *end note*]
 An entity is *templated* if it is
 - a template,
 - an entity defined [[basic.def]] or created [[class.temporary]] in a
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
+[*Note 6*: A local class, a local or block variable, or a friend
+function defined in a templated entity is a templated
+entity. — *end note*]
+A *templated function* is a function template or a function that is
+templated. A *templated class* is a class template or a class that is
+templated. A *templated variable* is a variable template or a variable
+that is templated.
 A *template-declaration* is written in terms of its template parameters.
 The optional *requires-clause* following a *template-parameter-list*
 allows the specification of constraints [[temp.constr.decl]] on template
 arguments [[temp.arg]]. The *requires-clause* introduces the
 *constraint-expression* that results from interpreting the
 *constraint-logical-or-expression* as a *constraint-expression*. The
 *constraint-logical-or-expression* of a *requires-clause* is an
 unevaluated operand [[expr.context]].
+[*Note 7*:
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.
 type-constraint:
   nested-name-specifierₒₚₜ concept-name
   nested-name-specifierₒₚₜ concept-name '<' template-argument-listₒₚₜ '>'
 ```
+The component names of a *type-constraint* are its *concept-name* and
+those of its *nested-name-specifier* (if any).
 [*Note 1*: The `>` token following the *template-parameter-list* of a
+*type-parameter* can be the product of replacing a `>>` token by two
 consecutive `>` tokens [[temp.names]]. — *end note*]
 There is no semantic difference between `class` and `typename` in a
 *type-parameter-key*. `typename` followed by an *unqualified-id* names a
 template type parameter. `typename` followed by a *qualified-id* denotes
+the type in a non-type[^1]
+*parameter-declaration*. A *template-parameter* of the form `class`
+*identifier* is a *type-parameter*.
 [*Example 1*:
 ``` cpp
 class T { ... };
 A storage class shall not be specified in a *template-parameter*
 declaration. Types shall not be defined in a *template-parameter*
 declaration.
+The *identifier* in a *type-parameter* is not looked up. A
+*type-parameter* whose *identifier* does not follow an ellipsis defines
 its *identifier* to be a *typedef-name* (if declared without `template`)
 or *template-name* (if declared with `template`) in the scope of the
 template declaration.
 [*Note 2*:
+A template argument can be a class template or alias template. For
 example,
 ``` cpp
 template<class T> class myarray { ... };
 - an lvalue reference type, or
 - a literal class type with the following properties:
   - all base classes and non-static data members are public and
     non-mutable and
   - the types of all bases classes and non-static data members are
+    structural types or (possibly multidimensional) array thereof.
 An *id-expression* naming a non-type *template-parameter* of class type
 `T` denotes a static storage duration object of type `const T`, known as
 a *template parameter object*, whose value is that of the corresponding
 template argument after it has been converted to the type of the
   i++;                          // error: change of template-parameter value
   &x;                           // OK
   &i;                           // error: address of non-reference template-parameter
   &a;                           // OK
+  int& ri = i;                  // error: attempt to bind non-const reference to temporary
+  const int& cri = i;           // OK, const reference binds to temporary
+  const A& ra = a;              // OK, const reference binds to a template parameter object
 }
 ```
 — *end example*]
 parameter pack [[temp.variadic]]. A default *template-argument* may be
 specified in a template declaration. A default *template-argument* shall
 not be specified in the *template-parameter-list*s of the definition of
 a member of a class template that appears outside of the member’s class.
 A default *template-argument* shall not be specified in a friend class
+template declaration. If a friend function template declaration D
 specifies a default *template-argument*, that declaration shall be a
+definition and there shall be no other declaration of the function
+template which is reachable from D or from which D is reachable.
 The set of default *template-argument*s available for use is obtained by
 merging the default arguments from all prior declarations of the
 template in the same way default function arguments are
 [[dcl.fct.default]].
 template<class... T, class U> void g() { }      // error
 ```
 — *end example*]
 When parsing a default *template-argument* for a non-type
 *template-parameter*, the first non-nested `>` is taken as the end of
 the *template-parameter-list* rather than a greater-than operator.
+[*Example 8*:
 ``` cpp
 template<int i = 3 > 4 >        // syntax error
 class X { ... };
 A *template-parameter* of a template *template-parameter* is permitted
 to have a default *template-argument*. When such default arguments are
 specified, they apply to the template *template-parameter* in the scope
 of the template *template-parameter*.
+[*Example 9*:
 ``` cpp
 template <template <class TT = float> class T> struct A {
   inline void f();
   inline void g();
 *type-constraint* that contains an unexpanded parameter pack is a pack
 expansion. A template parameter pack that is a pack expansion shall not
 expand a template parameter pack declared in the same
 *template-parameter-list*.
+[*Example 10*:
 ``` cpp
 template <class... Types>                       // Types is a template type parameter pack
    class Tuple;                                 // but not a pack expansion
   constant-expression
   type-id
   id-expression
 ```
+The component name of a *simple-template-id*, *template-id*, or
+*template-name* is the first name in it.
+A `<` is interpreted as the delimiter of a *template-argument-list* if
+it follows a name that is not a *conversion-function-id* and
+- that follows the keyword `template` or a `~` after a
+ *nested-name-specifier* or in a class member access expression, or
+- for which name lookup finds the injected-class-name of a class
+  template or finds any declaration of a template, or
+- that is an unqualified name for which name lookup either finds one or
+  more functions or finds nothing, or
+- that is a terminal name in a *using-declarator* [[namespace.udecl]],
+  in a *declarator-id* [[dcl.meaning]], or in a type-only context other
+  than a *nested-name-specifier* [[temp.res]].
+[*Note 1*: If the name is an *identifier*, it is then interpreted as a
+*template-name*. The keyword `template` is used to indicate that a
+dependent qualified name [[temp.dep.type]] denotes a template where an
+expression might appear. — *end note*]
+[*Example 1*:
+``` cpp
+struct X {
+  template<std::size_t> X* alloc();
+  template<std::size_t> static X* adjust();
+};
+template<class T> void f(T* p) {
+  T* p1 = p->alloc<200>();              // error: < means less than
+  T* p2 = p->template alloc<200>();     // OK, < starts template argument list
+  T::adjust<100>();                     // error: < means less than
+  T::template adjust<100>();            // OK, < starts template argument list
+}
+```
+— *end example*]
+When parsing a *template-argument-list*, the first non-nested `>`[^2]
+is taken as the ending delimiter rather than a greater-than operator.
+Similarly, the first non-nested `>>` is treated as two consecutive but
 distinct `>` tokens, the first of which is taken as the end of the
 *template-argument-list* and completes the *template-id*.
+[*Note 2*: The second `>` token produced by this replacement rule can
+terminate an enclosing *template-id* construct or it can be part of a
 different construct (e.g., a cast). — *end note*]
+[*Example 2*:
 ``` cpp
 template<int i> class X { ... };
 X< 1>2 > x1;                            // syntax error
 Y<X<(6>>1)>> x5;                        // OK
 ```
 — *end example*]
+The keyword `template` shall not appear immediately after a declarative
+*nested-name-specifier* [[expr.prim.id.qual]].
+A name prefixed by the keyword `template` shall be followed by a
+template argument list or refer to a class template or an alias
+template. The latter case is deprecated [[depr.template.template]]. The
+keyword `template` shall not appear immediately before a `~` token (as
+to name a destructor).
+[*Note 3*: The keyword `template` cannot be applied to non-template
 members of class templates. — *end note*]
+[*Note 4*: As is the case with the `typename` prefix, the `template`
+prefix is allowed even when lookup for the name would already find a
+template. — *end note*]
 [*Example 3*:
 ``` cpp
 template <class T> struct A {
   template <class U> void f(U);
 };
 template <class T> void f(T t) {
   A<T> a;
+  a.template f<>(t);                    // OK, calls template
   a.template f(t);                      // error: not a template-id
 }
 template <class T> struct B {
   template <class T2> struct C { };
 };
+// deprecated: T::C is assumed to name a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
 D<B<int> > db;
 ```
 — *end example*]
 — *end example*]
 When the *template-name* of a *simple-template-id* names a constrained
 non-function template or a constrained template *template-parameter*,
+and all *template-argument*s in the *simple-template-id* are
+non-dependent [[temp.dep.temp]], the associated constraints
 [[temp.constr.decl]] of the constrained template shall be satisfied
 [[temp.constr.constr]].
 [*Example 5*:
 name a template specialization. A concept-id evaluates to `true` if the
 concept’s normalized *constraint-expression* [[temp.constr.decl]] is
 satisfied [[temp.constr.constr]] by the specified template arguments and
 `false` otherwise.
+[*Note 5*: Since a *constraint-expression* is an unevaluated operand, a
 concept-id appearing in a *constraint-expression* is not evaluated
 except as necessary to determine whether the normalized constraints are
 satisfied. — *end note*]
 [*Example 6*:
 — *end example*]
 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
+### General <a id="temp.arg.general">[[temp.arg.general]]</a>
 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
 }
 ```
 — *end example*]
+The template argument list of a *template-head* is a template argument
+list in which the nᵗʰ template argument has the value of the nᵗʰ
+template parameter of the *template-head*. If the nᵗʰ template parameter
+is a template parameter pack [[temp.variadic]], the nᵗʰ template
+argument is a pack expansion whose pattern is the name of the template
+parameter pack.
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
 corresponding *template-parameter*.[^3]
 [*Example 2*:
 }
 ```
 — *end example*]
+[*Note 1*: Names used in a *template-argument* are subject to access
+control where they appear. Because a *template-parameter* is not a class
+member, no access control applies. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
 };
 class Y {
 private:
   struct S { ... };
+  X<S> x;           // OK, S is accessible
                     // X<Y::S> has a static member of type Y::S
+                    // OK, even though Y::S is private
 };
 X<Y::S> y;          // error: S not accessible
 ```
 [*Example 5*:
 ``` cpp
 template<class T = char> class String;
+String<>* p;                    // OK, String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
+Tuple<>* t;                     // OK, Elements is empty
 Tuple* u;                       // syntax error
 ```
 — *end example*]
 ``` cpp
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
+  p->A<int>::~A();              // OK, destructor call
+  q->A<int>::~A<int>();         // OK, destructor call
 }
 ```
 — *end example*]
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
+When name lookup for the component name of a *template-id* finds an
+overload set, both non-template functions in the overload set and
+function templates in the overload set for which the
+*template-argument*s do not match the *template-parameter*s are ignored.
+[*Note 2*: If none of the function templates have matching
+*template-parameter*s, the program is ill-formed. — *end note*]
 When a *simple-template-id* does not name a function, a default
 *template-argument* is implicitly instantiated [[temp.inst]] when the
 value of that default argument is needed.
 }
 ```
 — *end example*]
+[*Note 1*: A template type argument can be an incomplete type
+[[term.incomplete.type]]. — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
 If the type `T` of a *template-parameter* [[temp.param]] contains a
 placeholder type [[dcl.spec.auto]] or a placeholder for a deduced class
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
 A *template-argument* for a template *template-parameter* shall be the
 name of a class template or an alias template, expressed as
+*id-expression*. Only primary templates are considered when matching the
+template template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
+Any partial specializations [[temp.spec.partial]] associated with the
+primary template are considered when a specialization based on the
+template *template-parameter* is instantiated. If a specialization is
+not reachable from the point of instantiation, and it would have been
+selected had it been reachable, the program is ill-formed, no diagnostic
+required.
 [*Example 1*:
 ``` cpp
 template<class T> class A {     // primary template
 template <class T1, class T2> struct B;
 template <int N> struct C;
 template <class T1, int N> struct D;
 template <class T1, class T2, int N = 17> struct E;
+eval<A<int>> eA;                // OK, matches partial specialization of eval
+eval<B<int, float>> eB;         // OK, matches partial specialization of eval
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
 If the rewrite produces an invalid type, then `P` is not at least as
 specialized as `A`.
 ## Template constraints <a id="temp.constr">[[temp.constr]]</a>
+### General <a id="temp.constr.general">[[temp.constr.general]]</a>
+[*Note 1*: Subclause [[temp.constr]] defines the meaning of constraints
+on template arguments. The abstract syntax and satisfaction rules are
 defined in [[temp.constr.constr]]. Constraints are associated with
 declarations in [[temp.constr.decl]]. Declarations are partially ordered
 by their associated constraints [[temp.constr.order]]. — *end note*]
 ### Constraints <a id="temp.constr.constr">[[temp.constr.constr]]</a>
+#### General <a id="temp.constr.constr.general">[[temp.constr.constr.general]]</a>
 A *constraint* is a sequence of logical operations and operands that
 specifies requirements on template arguments. The operands of a logical
 operation are constraints. There are three different kinds of
 constraints:
   requires (sizeof(T) > 1) && (get_value<T>())
     void f(T);      // has associated constraint sizeof(T) > 1 ∧ get_value<T>()
 void f(int);
+f('a'); // OK, calls f(int)
 ```
 In the satisfaction of the associated constraints [[temp.constr.decl]]
 of `f`, the constraint `sizeof(char) > 1` is not satisfied; the second
 operand is not checked for satisfaction.
 }
 ```
 — *end example*]
+As specified in [[temp.over.link]], if the validity or meaning of the
+program depends on whether two constructs are equivalent, and they are
+functionally equivalent but not equivalent, the program is ill-formed,
+no diagnostic required.
 [*Example 2*:
 ``` cpp
 template <unsigned N> void f2()
 ``` cpp
 template<typename T> concept C1 = sizeof(T) == 1;
 template<typename T> concept C2 = C1<T> && 1 == 2;
 template<typename T> concept C3 = requires { typename T::type; };
+template<typename T> concept C4 = requires (T x) { ++x; };
 template<C2 U> void f1(U);      // #1
 template<C3 U> void f2(U);      // #2
 template<C4 U> void f3(U);      // #3
 ```
 — *end example*]
 ### Partial ordering by constraints <a id="temp.constr.order">[[temp.constr.order]]</a>
 A constraint P *subsumes* a constraint Q if and only if, for every
+disjunctive clause Pᵢ in the disjunctive normal form[^4]
+of P, Pᵢ subsumes every conjunctive clause Qⱼ in the conjunctive normal
+form[^5]
 of Q, where
 - a disjunctive clause Pᵢ subsumes a conjunctive clause Qⱼ if and only
   if there exists an atomic constraint Pᵢₐ in Pᵢ for which there exists
   an atomic constraint $Q_{jb}$ in Qⱼ such that Pᵢₐ subsumes $Q_{jb}$,
 - the best viable candidate of non-template functions
   [[over.match.best]],
 - the address of a non-template function [[over.over]],
 - the matching of template template arguments [[temp.arg.template]],
 - the partial ordering of class template specializations
+  [[temp.spec.partial.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
 A declaration `D1` is *at least as constrained* as a declaration `D2` if
 If an expression e is type-dependent [[temp.dep.expr]], `decltype(e)`
 denotes a unique dependent type. Two such *decltype-specifier*s refer to
 the same type only if their *expression*s are equivalent
 [[temp.over.link]].
+[*Note 1*: However, such a type might be aliased, e.g., by a
 *typedef-name*. — *end note*]
 ## Template declarations <a id="temp.decls">[[temp.decls]]</a>
+### General <a id="temp.decls.general">[[temp.decls.general]]</a>
+The template parameters of a template are specified in the angle bracket
+enclosed list that immediately follows the keyword `template`.
+A *primary template* declaration is one in which the name of the
+template is not followed by a *template-argument-list*. The template
+argument list of a primary template is the template argument list of its
+*template-head* [[temp.arg]]. A template declaration in which the name
+of the template is followed by a *template-argument-list* is a partial
+specialization [[temp.spec.partial]] of the template named in the
+declaration, which shall be a class or variable template.
 For purposes of name lookup and instantiation, default arguments,
 *type-constraint*s, *requires-clause*s [[temp.pre]], and
 *noexcept-specifier*s of function templates and of member functions of
 class templates are considered definitions; each default argument,
 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
+definition or to any other default arguments, *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
 are considered definitions.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
+#### General <a id="temp.class.general">[[temp.class.general]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
+It is possible for a single class template `List` to provide an
+unbounded set of class definitions: one class `List<T>` for every type
+`T`, each describing a linked list of elements of type `T`. Similarly, a
+class template `Array` describing a contiguous, dynamic array can be
+defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
+declared and that a *type-name* `T` can be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
+[*Note 1*:
+When a member of a class template is defined outside of the class
+template definition, the member definition is defined as a template
+definition with the *template-head* equivalent to that of the class
+template. The names of the template parameters used in the definition of
+the member can differ from the template parameter names used in the
+class template definition. The class template name in the member
+definition is followed by the template argument list of the
+*template-head* [[temp.arg]].
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
   void g();
   void h();
   template<D U> struct Inner;
 };
+template<C A> void S<A>::f() { }        // OK, template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
+— *end note*]
+In a partial specialization, explicit specialization or explicit
+instantiation of a class template, the *class-key* shall agree in kind
+with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
+function can be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
+template argument deduction [[over.match.class.deduct]], all reachable
+deduction guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
+the *simple-template-id*. A *deduction-guide* shall inhabit the scope to
+which the corresponding class template belongs and, for a member class
+template, have the same access. Two deduction guide declarations for the
+same class template shall not have equivalent
+*parameter-declaration-clause*s if either is reachable from the other.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
 ``` cpp
 template<class T> struct A {
   class B;
 };
+A<int>::B* b1;                          // OK, requires A to be defined but not A::B
 template<class T> class A<T>::B { };
+A<int>::B  b2;                          // OK, requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
+template <> int A<int>::i[] = { 1 };    // OK, 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
 }
 ```
 — *end example*]
+A member function template shall not be declared `virtual`.
 [*Example 4*:
 ``` cpp
 template <class T> struct AA {
   virtual void f(int);
 };
 class D : public B {
   template <class T> void f(T); // does not override B::f(int)
+  void f(int i) { f<>(i); }     // overriding function that calls the function template specialization
 };
 ```
 — *end example*]
+[*Note 1*:
 A specialization of a conversion function template is referenced in the
 same way as a non-template conversion function that converts to the same
+type [[class.conv.fct]].
 [*Example 6*:
 ``` cpp
 struct A {
 }
 ```
 — *end example*]
+There is no syntax to form a *template-id* [[temp.names]] by providing
+an explicit template argument list [[temp.arg.explicit]] for a
+conversion function template.
+— *end note*]
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 A *template parameter pack* is a template parameter that accepts zero or
 more template arguments.
     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
+    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>>
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
+  void g(Args ... args) {                   // OK, Args is expanded by the function parameter pack args
+    f(const_cast<const Args*>(&args)...);   // OK, ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
+    f(h(args ...) + args ...);              // OK, first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
+The instantiation of a pack expansion considers items
+`E₁`, `E₂`, …, `E_N`, where N is the number of elements in the pack
+expansion parameters. Each `Eᵢ` is generated by instantiating the
+pattern and replacing each pack expansion parameter with its iᵗʰ
+element. Such an element, in the context of the instantiation, is
+interpreted as follows:
+- if the pack is a template parameter pack, the element is an
+ *id-expression* (for a non-type template parameter pack), a
+ *typedef-name* (for a type template parameter pack declared without
+  `template`), or a *template-name* (for a type template parameter pack
+  declared with `template`), designating the iᵗʰ corresponding type or
+  value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
+  pack declaration.
+When N is zero, the instantiation of a pack expansion does not alter the
+syntactic interpretation of the enclosing construct, even in cases where
+omitting the pack expansion entirely would otherwise be ill-formed or
+would result in an ambiguity in the grammar.
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
+an integral constant with value N.
+The instantiation of a *fold-expression* [[expr.prim.fold]] produces:
+- `(` `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for a unary
+  left fold,
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))`
+ `)` for a unary right fold,
+- `(` `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for
+  a binary left fold, and
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$
+  *op* E`)))` `)` for a binary right fold.
+In each case, *op* is the *fold-operator*. For a binary fold, E is
+generated by instantiating the *cast-expression* that did not contain an
+unexpanded pack.
+[*Example 6*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
+If N is zero for a unary fold, the value of the expression is shown in
+[[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
+The instantiation of any other pack expansion produces a list of
+elements `E₁`, `E₂`, …, `E_N`.
+[*Note 1*: The variety of list varies with the context:
+*expression-list*, *base-specifier-list*, *template-argument-list*,
+etc. — *end note*]
+When N is zero, the instantiation of the expansion produces an empty
+list.
+[*Example 7*:
+``` cpp
+template<class... T> struct X : T... { };
+template<class... T> void f(T... values) {
+  X<T...> x(values...);
+}
+template void f<>();    // OK, X<> has no base classes
+                        // x is a variable of type X<> that is value-initialized
+```
+— *end example*]
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
+template, or a non-template function or class.
 [*Example 1*:
 ``` cpp
 template<class T> class task;
 template has the class template specialization `task<int>` as a friend,
 and has all specializations of the class template `frd` as friends.
 — *end example*]
+Friend classes, class templates, functions, or function templates can be
+declared within a class template. When a template is instantiated, its
+friend declarations are found by name lookup as if the specialization
+had been explicitly declared at its point of instantiation.
+[*Note 1*: They can introduce entities that belong to an enclosing
+namespace scope [[dcl.meaning]], in which case they are attached to the
+same module as the class template [[module.unit]]. — *end note*]
 A friend template may be declared within a class or class template. A
 friend function template may be defined within a class or class
 template, but a friend class template may not be defined in a class or
 class template. In these cases, all specializations of the friend class
 or friend function template are friends of the class or class template
 — *end example*]
 A template friend declaration specifies that all specializations of that
 template, whether they are implicitly instantiated [[temp.inst]],
+partially specialized [[temp.spec.partial]] or explicitly specialized
 [[temp.expl.spec]], are friends of the class containing the template
 friend declaration.
 [*Example 3*:
 A template friend declaration may declare a member of a dependent type
 to be a friend. The friend declaration shall declare a function or
 specify a type with an *elaborated-type-specifier*, in either case with
 a *nested-name-specifier* ending with a *simple-template-id*, *C*, whose
 *template-name* names a class template. The template parameters of the
+template friend declaration shall be deducible from *C*
+[[temp.deduct.type]]. In this case, a member of a specialization *S* of
 the class template is a friend of the class granting friendship if
 deduction of the template parameters of *C* from *S* succeeds, and
 substituting the deduced template arguments into the friend declaration
+produces a declaration that corresponds to the member of the
+specialization.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
 };                                              // of those function templates
 ```
 — *end example*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 [*Example 5*:
 a template parameter from an enclosing template shall be a definition.
 Such a constrained friend function or function template declaration does
 not declare the same function or function template as a declaration in
 any other scope.
+### Partial specialization <a id="temp.spec.partial">[[temp.spec.partial]]</a>
+#### General <a id="temp.spec.partial.general">[[temp.spec.partial.general]]</a>
+A partial specialization of a template provides an alternative
 definition of the template that is used instead of the primary
 definition when the arguments in a specialization match those given in
+the partial specialization [[temp.spec.partial.match]]. A declaration of
+the primary template shall precede any partial specialization of that
+template. A partial specialization shall be reachable from any use of a
+template specialization that would make use of the partial
+specialization as the result of an implicit or explicit instantiation;
+no diagnostic is required.
+Two partial specialization declarations declare the same entity if they
+are partial specializations of the same template and have equivalent
+*template-head*s and template argument lists [[temp.over.link]]. Each
+partial specialization is a distinct template.
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 — *end example*]
+A partial specialization may be constrained [[temp.constr]].
 [*Example 2*:
 ``` cpp
 template<typename T> concept C = true;
 specialized because the template arguments are equivalent, but the
 partial specialization is more constrained [[temp.constr.order]].
 — *end example*]
+The template argument list of a partial specialization is the
+*template-argument-list* following the name of the template.
+A partial specialization may be declared in any scope in which the
+corresponding primary template may be defined
+[[dcl.meaning]], [[class.mem]], [[temp.mem]].
+[*Example 3*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
 A<short>::C::B<int*> absip;                     // uses partial specialization #2
 ```
 — *end example*]
+Partial specialization declarations do not introduce a name. Instead,
+when the primary template name is used, any reachable partial
+specializations of the primary template are also considered.
+[*Note 1*: One consequence is that a *using-declaration* which refers
+to a class template does not restrict the set of partial specializations
+that are found through the *using-declaration*. — *end note*]
+[*Example 4*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
 — *end example*]
 A non-type argument is non-specialized if it is the name of a non-type
 parameter. All other non-type arguments are specialized.
+Within the argument list of a partial specialization, the following
+restrictions apply:
 - The type of a template parameter corresponding to a specialized
+  non-type argument shall not be dependent on a parameter of the partial
   specialization.
+  \[*Example 5*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
   template< int X, int (*array_ptr)[X] > class A {};
   int array[5];
   template< int X > class A<X,&array> { };        // error
   ```
   — *end example*]
+- The partial specialization shall be more specialized than the primary
+ template [[temp.spec.partial.order]].
+- The template parameter list of a partial specialization shall not
+ contain default template argument values.[^8]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
 to specify template arguments of the *simple-template-id* of the partial
 specialization.
+[*Note 2*: The template arguments can be private types or objects that
 would normally not be accessible. Dependent names cannot be checked when
 declaring the partial specialization, but will be checked when
 substituting into the partial specialization. — *end note*]
+#### Matching of partial specializations <a id="temp.spec.partial.match">[[temp.spec.partial.match]]</a>
+When a template is used in a context that requires an instantiation of
+the template, it is necessary to determine whether the instantiation is
+to be generated using the primary template or one of the partial
+specializations. This is done by matching the template arguments of the
+template specialization with the template argument lists of the partial
+specializations.
+- If exactly one matching partial specialization is found, the
+ instantiation is generated from that partial specialization.
+- If more than one matching partial specialization is found, the partial
+ order rules [[temp.spec.partial.order]] are used to determine whether
+ one of the partial specializations is more specialized than the
+ others. If such a partial specialization exists, the instantiation is
+ generated from that partial specialization; otherwise, the use of the
+ template is ambiguous and the program is ill-formed.
 - If no matches are found, the instantiation is generated from the
   primary template.
 A partial specialization matches a given actual template argument list
 if the template arguments of the partial specialization can be deduced
 template <int I> struct B<I, I*2, 2> {};    // OK
 ```
 — *end example*]
+In a name that refers to a specialization of a class or variable
+template (e.g., `A<int, int, 1>`), the argument list shall match the
+template parameter list of the primary template. The template arguments
+of a partial specialization are deduced from the arguments of the
+primary template.
+#### Partial ordering of partial specializations <a id="temp.spec.partial.order">[[temp.spec.partial.order]]</a>
+For two partial specializations, the first is *more specialized* than
+the second if, given the following rewrite to two function templates,
+the first function template is more specialized than the second
+according to the ordering rules for function templates
 [[temp.func.order]]:
 - Each of the two function templates has the same template parameters
   and associated constraints [[temp.constr.decl]] as the corresponding
   partial specialization.
 The partial specialization \#2 is more specialized than \#1 because `B`
 is more specialized than `A`.
 — *end example*]
+#### Members of class template partial specializations <a id="temp.spec.partial.member">[[temp.spec.partial.member]]</a>
+The members of the class template partial specialization are unrelated
+to the members of the primary template. Class template partial
+specialization members that are used in a way that requires a definition
+shall be defined; the definitions of members of the primary template are
+never used as definitions for members of a class template partial
+specialization. An explicit specialization of a member of a class
+template partial specialization is declared in the same way as an
+explicit specialization of a member of the primary template.
 [*Example 1*:
 ``` cpp
 // primary class template
 — *end example*]
 If a member template of a class template is partially specialized, the
 member template partial specializations are member templates of the
 enclosing class template; if the enclosing class template is
+instantiated [[temp.inst]], [[temp.explicit]], a declaration for every
+member template partial specialization is also instantiated as part of
+creating the members of the class template specialization. If the
+primary member template is explicitly specialized for a given (implicit)
+specialization of the enclosing class template, the partial
 specializations of the member template are ignored for this
 specialization of the enclosing class template. If a partial
 specialization of the member template is explicitly specialized for a
 given (implicit) specialization of the enclosing class template, the
 primary member template and its other partial specializations are still
 — *end example*]
 ### Function templates <a id="temp.fct">[[temp.fct]]</a>
+#### General <a id="temp.fct.general">[[temp.fct.general]]</a>
 A function template defines an unbounded set of related functions.
 [*Example 1*:
+A family of sort functions can be declared like this:
 ``` cpp
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 — *end example*]
+[*Note 1*: A function template can have the same name as other function
+templates and non-template functions [[dcl.fct]] in the same
+scope. — *end note*]
+A non-template function is not related to a function template (i.e., it
+is never considered to be a specialization), even if it has the same
+name and type as a potentially generated function template
+specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
 the relationship between the template parameters and the rest of the
 signature.
 [*Note 1*:
+Two distinct function templates can have identical function return types
 and function parameter lists, even if overload resolution alone cannot
 distinguish them.
 ``` cpp
 template<class T> void f();
+template<int I> void f();       // OK, overloads the first template
                                 // distinguishable with an explicit template argument list
 ```
 — *end note*]
 expression. Two unevaluated operands that do not involve template
 parameters are considered equivalent if two function definitions
 containing the expressions would satisfy the one-definition rule, except
 that the tokens used to name types and declarations may differ as long
 as they name the same entities, and the tokens used to form concept-ids
+[[temp.names]] may differ as long as the two *template-id*s are the same
+[[temp.type]].
 [*Note 3*: For instance, `A<42>` and `A<40+2>` name the same
 type. — *end note*]
 Two *lambda-expression*s are never considered equivalent.
 [*Note 4*: The intent is to avoid *lambda-expression*s appearing in the
 signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
+only the name itself is considered, not the result of name lookup.
+[*Note 5*: If such a dependent name is unqualified, it is looked up
+from the first declaration of the function template
+[[temp.dep.candidate]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <class T> decltype(g(T())) h();
 int g(int);
 template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup…
   { return g(T()); }                            // …{} although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
+                                                // not considered at the first declaration of h()
 // ill-formed, no diagnostic required: the two expressions are functionally equivalent but not equivalent
 template <int N> void foo(const char (*s)[([]{}, N)]);
 template <int N> void foo(const char (*s)[([]{}, N)]);
 same value. Two unevaluated operands that are not equivalent are
 functionally equivalent if, for any given set of template arguments, the
 expressions perform the same operations in the same order with the same
 entities.
+[*Note 6*: For instance, one could have redundant
 parentheses. — *end note*]
+[*Example 4*:
+``` cpp
+template<int I> concept C = true;
+template<typename T> struct A {
+  void f() requires C<42>;      // #1
+  void f() requires true;       // OK, different functions
+};
+```
+— *end example*]
 Two *template-head*s are *equivalent* if their
 *template-parameter-list*s have the same length, corresponding
 *template-parameter*s are equivalent and are both declared with
 *type-constraint*s that are equivalent if either *template-parameter* is
 declared with a *type-constraint*, and if either *template-head* has a
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
+If the validity or meaning of the program depends on whether two
+constructs are equivalent, and they are functionally equivalent but not
+equivalent, the program is ill-formed, no diagnostic required.
+Furthermore, if two function templates that do not correspond
+- have the same name,
+- have corresponding signatures [[basic.scope.scope]],
+- would declare the same entity [[basic.link]] considering them to
+  correspond, and
+- accept and are satisfied by the same set of template argument lists,
+the program is ill-formed, no diagnostic required.
+[*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
+If multiple function templates share a name, the use of that name can be
+ambiguous because template argument deduction [[temp.deduct]] may
+identify a specialization for more than one function template. *Partial
+ordering* of overloaded function template declarations is used in the
+following contexts to select the function template to which a function
+template specialization refers:
 - during overload resolution for a call to a function template
   specialization [[over.match.best]];
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
+  specialization is selected to match a placement operator new
+  [[basic.stc.dynamic.deallocation]], [[expr.new]];
 - when a friend function declaration [[temp.friend]], an explicit
   instantiation [[temp.explicit]] or an explicit specialization
   [[temp.expl.spec]] refers to a function template specialization.
 Partial ordering selects which of two function templates is more
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
+  f(&i);                                                // OK, calls #2
+  g(&i);                                                // OK, calls #3
 }
 ```
 — *end example*]
 void f(C auto &, auto &) = delete;
 template <C Q> void f(Q &, C auto &);
 void g(struct A *ap, struct B *bp) {
+  f(*ap, *bp);                  // OK, can use different methods to produce template parameters
 }
 template <typename T, typename U> struct X {};
 template <typename T, C U, typename V> bool operator==(X<T, U>, V) = delete;
 template <C T, C U, C V>               bool operator==(T, X<U, V>);
 void h() {
+  X<void *, int>{} == 0;        // OK, correspondence of [T, U, V] and [U, V, T]
 }
 ```
 — *end example*]
 [*Example 1*:
 ``` cpp
 template<class T> struct Alloc { ... };
 template<class T> using Vec = vector<T, Alloc<T>>;
+Vec<int> v;         // same as vector<int, Alloc<int>> v;
 template<class T>
   void process(Vec<T>& v)
   { ... }
 f(v);               // error: Vec not deduced
 template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
+g(v);               // OK, TT = vector
 ```
 — *end example*]
 However, if the *template-id* is dependent, subsequent template argument
 A *concept* is a template that defines constraints on its template
 arguments.
 ``` bnf
 concept-definition:
+  concept concept-name attribute-specifier-seqₒₚₜ '=' constraint-expression ';'
 ```
 ``` bnf
 concept-name:
   identifier
 ```
 A *concept-definition* declares a concept. Its *identifier* becomes a
+*concept-name* referring to that concept within its scope. The optional
+*attribute-specifier-seq* appertains to the concept.
 [*Example 1*:
 ``` cpp
 template<typename T>
 T f2(T x) { return x; }
 ```
 — *end example*]
+A *concept-definition* shall inhabit a namespace scope
 [[basic.scope.namespace]].
 A concept shall not have associated constraints [[temp.constr.decl]].
 A concept is not instantiated [[temp.spec]].
 [*Note 1*: A concept-id [[temp.names]] is evaluated as an expression. A
 concept cannot be explicitly instantiated [[temp.explicit]], explicitly
+specialized [[temp.expl.spec]], or partially specialized
+[[temp.spec.partial]]. — *end note*]
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its
 *prototype parameter*. A *type concept* is a concept whose prototype
 parameter is a type *template-parameter*.
 ## Name resolution <a id="temp.res">[[temp.res]]</a>
+### General <a id="temp.res.general">[[temp.res.general]]</a>
+A name that appears in a declaration D of a template T is looked up from
+where it appears in an unspecified declaration of T that either is D
+itself or is reachable from D and from which no other declaration of T
+that contains the usage of the name is reachable. If the name is
+dependent (as specified in [[temp.dep]]), it is looked up for each
+specialization (after substitution) because the lookup depends on a
+template parameter.
+[*Note 1*: Some dependent names are also looked up during parsing to
+determine that they are dependent or to interpret following `<` tokens.
+Uses of other names might be type-dependent or value-dependent
+[[temp.dep.expr]], [[temp.dep.constexpr]]. A *using-declarator* is never
+dependent in a specialization and is therefore replaced during lookup
+for that specialization [[basic.lookup]]. — *end note*]
 [*Example 1*:
 ``` cpp
+struct A { operator int(); };
+template<class B, class T>
+struct D : B {
+  T get() { return operator T(); }      // conversion-function-id is dependent
+};
+int f(D<A, int> d) { return d.get(); }  // OK, lookup finds A::operator int
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+void f(char);
+template<class T> void g(T t) {
+  f(1);             // f(char)
+  f(T(1)); // dependent
+  f(t);             // dependent
+  dd++;             // not dependent; error: declaration for dd not found
 }
+enum E { e };
+void f(E);
+double dd;
+void h() {
+  g(e);             // will cause one call of f(char) followed by two calls of f(E)
+  g('a');           // will cause three calls of f(char)
+}
+```
+— *end example*]
+[*Example 3*:
+``` cpp
+struct A {
+  struct B { ... };
+  int a;
+  int Y;
+};
+int a;
+template<class T> struct Y : T {
+  struct B { ... };
+  B b;                          // The B defined in Y
+  void f(int i) { a = i; }      // ::a
+  Y* p;                         // Y<T>
 };
+Y<A> ya;
 ```
+The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
+not affect the binding of names in `Y<A>`.
 — *end example*]
+If the validity or meaning of the program would be changed by
+considering a default argument or default template argument introduced
+in a declaration that is reachable from the point of instantiation of a
+specialization [[temp.point]] but is not found by lookup for the
+specialization, the program is ill-formed, no diagnostic required.
 ``` bnf
 typename-specifier:
   typename nested-name-specifier identifier
   typename nested-name-specifier 'templateₒₚₜ ' simple-template-id
 ```
+The component names of a *typename-specifier* are its *identifier* (if
+any) and those of its *nested-name-specifier* and *simple-template-id*
+(if any). A *typename-specifier* denotes the type or class template
+denoted by the *simple-type-specifier* [[dcl.type.simple]] formed by
+omitting the keyword `typename`.
+[*Note 2*: The usual qualified name lookup [[basic.lookup.qual]]
+applies even in the presence of `typename`. — *end note*]
+[*Example 4*:
 ``` cpp
 struct A {
   struct X { };
   int X;
   typename T::X x;
 }
 void foo() {
   A a;
   B b;
+  f(b);             // OK, T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
 — *end example*]
+A qualified or unqualified name is said to be in a *type-only context*
+if it is the terminal name of
+- a *typename-specifier*, *nested-name-specifier*,
+ *elaborated-type-specifier*, *class-or-decltype*, or
+- a *type-specifier* of a
+  - *new-type-id*,
+  - *defining-type-id*,
+ - *conversion-type-id*,
+ - *trailing-return-type*,
+  - default argument of a *type-parameter*, or
+  - *type-id* of a `static_cast`, `const_cast`, `reinterpret_cast`, or
+    `dynamic_cast`, or
+- a *decl-specifier* of the *decl-specifier-seq* of a
   - *simple-declaration* or a *function-definition* in namespace scope,
   - *member-declaration*,
+  - *parameter-declaration* in a *member-declaration*,[^10] unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *declarator* of a function or function
     template declaration whose *declarator-id* is qualified, unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *lambda-declarator* or
     *requirement-parameter-list*, unless that *parameter-declaration*
     appears in a default argument, or
   - *parameter-declaration* of a (non-type) *template-parameter*.
+[*Example 5*:
 ``` cpp
 template<class T> T::R f();             // OK, return type of a function declaration at global scope
 template<class T> void f(T::R);         // ill-formed, no diagnostic required: attempt to declare
                                         // a void variable template
 }
 ```
 — *end example*]
+A *qualified-id* whose terminal name is dependent and that is in a
+type-only context is considered to denote a type. A name that refers to
+a *using-declarator* whose terminal name is dependent is interpreted as
+a *typedef-name* if the *using-declarator* uses the keyword `typename`.
+[*Example 6*:
 ``` cpp
 template <class T> void f(int i) {
   T::x * i;         // expression, not the declaration of a variable i
 }
 }
 ```
 — *end example*]
 The validity of a template may be checked prior to any instantiation.
+[*Note 3*: Knowing which names are type names allows the syntax of
 every template to be checked in this way. — *end note*]
 The program is ill-formed, no diagnostic required, if:
+- no valid specialization, ignoring *static_assert-declaration*s that
+ fail, can be generated for a template or a substatement of a constexpr
+ if statement [[stmt.if]] within a template and the template is not
+  instantiated, or
+- any *constraint-expression* in the program, introduced or otherwise,
+  has (in its normal form) an atomic constraint A where no satisfaction
+  check of A could be well-formed and no satisfaction check of A is
+  performed, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
 - a hypothetical instantiation of a template immediately following its
   definition would be ill-formed due to a construct that does not depend
   on a template parameter, or
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
   corresponding construct in any actual instantiation of the template.
+[*Note 4*:
 This can happen in situations including the following:
 - a type used in a non-dependent name is incomplete at the point at
   which a template is defined but is complete at the point at which an
   instantiation is performed, or
 - lookup for a name in the template definition found a
+ *using-declaration*, but the lookup in the corresponding scope in the
+ instantiation does not find any declarations because the
+ *using-declaration* was a pack expansion and the corresponding pack is
+ empty, or
+- an instantiation uses a default argument or default template argument
+ that had not been defined at the point at which the template was
+ defined, or
 - constant expression evaluation [[expr.const]] within the template
   instantiation uses
+ - the value of a const object of integral or unscoped enumeration type
+ or
   - the value of a `constexpr` object or
   - the value of a reference or
   - the definition of a constexpr function,
   and that entity was not defined when the template was defined, or
 — *end note*]
 Otherwise, no diagnostic shall be issued for a template for which a
 valid specialization can be generated.
+[*Note 5*: If a template is instantiated, errors will be diagnosed
 according to the other rules in this document. Exactly when these errors
 are diagnosed is a quality of implementation issue. — *end note*]
+[*Example 7*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
     t = i;          // diagnosed if X::f is instantiated, and the assignment to t is an error
     p = i;          // may be diagnosed even if X::f is not instantiated
     p = j;          // may be diagnosed even if X::f is not instantiated
+    X<T>::g(t);     // OK
+    X<T>::h();      // may be diagnosed even if X::f is not instantiated
   }
   void g(T t) {
     +;              // may be diagnosed even if X::g is not instantiated
   }
 };
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
 — *end example*]
+[*Note 6*: For purposes of name lookup, default arguments and
 *noexcept-specifier*s of function templates and default arguments and
 *noexcept-specifier*s of member functions of class templates are
 considered definitions [[temp.decls]]. — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
+followed by the template argument list
+[[temp.decls.general]], [[temp.arg.general]] of the class template
+enclosed in `<>`.
+When the injected-class-name of a class template specialization or
+partial specialization is used as a *type-name*, it is equivalent to the
+*template-name* followed by the *template-argument*s of the class
+template specialization or partial specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
 — *end example*]
 The injected-class-name of a class template or class template
 specialization can be used as either a *template-name* or a *type-name*
+wherever it is named.
 [*Example 2*:
 ``` cpp
 template <class T> struct Base {
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
+template<class T, template<class> class U = T::Base> struct Third { };
+Third<Derived<int> > t;                 // OK, default argument uses injected-class-name as a template
 ```
 — *end example*]
 A lookup that finds an injected-class-name [[class.member.lookup]] can
 };
 ```
 — *end example*]
+The name of a *template-parameter* shall not be bound to any following
+declaration whose locus is contained by the scope to which the
+template-parameter belongs.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
+  int T;                                // error: template-parameter hidden
   void f() {
+    char T;                             // error: template-parameter hidden
   }
+  friend void T();                      // OK, no name bound
 };
+template<class X> class X;              // error: hidden by template-parameter
 ```
 — *end example*]
+Unqualified name lookup considers the template parameter scope of a
+*template-declaration* immediately after the outermost scope associated
+with the template declared (even if its parent scope does not contain
+the *template-parameter-list*).
+[*Note 1*: The scope of a class template, including its non-dependent
+base classes [[temp.dep.type]], [[class.member.lookup]], is searched
+before its template parameter scope. — *end note*]
 [*Example 6*:
 ``` cpp
+struct B { };
+namespace N {
+  typedef void V;
+  template<class T> struct A : B {
     typedef void C;
     void f();
     template<class U> void g(U);
   };
 }
+template<class V> void N::A<V>::f() {   // N::V not considered here
+ V v; // V is still the template parameter, not N::V
 }
+template<class B> template<class C> void N::A<B>::g(C) {
+  B b;                                  // B is the base class, not the template parameter
+  C c;                                  // C is the template parameter, not A's C
 }
 ```
 — *end example*]
 ### Dependent names <a id="temp.dep">[[temp.dep]]</a>
+#### General <a id="temp.dep.general">[[temp.dep.general]]</a>
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
 names. An expression may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
 when evaluated as a constant expression [[expr.const]] may depend on a
+template parameter) as described below.
+A *dependent call* is an expression, possibly formed as a non-member
+candidate for an operator [[over.match.oper]], of the form:
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
+where the *postfix-expression* is an *unqualified-id* and
 - any of the expressions in the *expression-list* is a pack expansion
+  [[temp.variadic]], or
 - any of the expressions or *braced-init-list*s in the *expression-list*
   is type-dependent [[temp.dep.expr]], or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
+The component name of an *unqualified-id* [[expr.prim.id.unqual]] is
+dependent if
+- it is a *conversion-function-id* whose *conversion-type-id* is
+  dependent, or
+- it is `operator=` and the current class is a templated entity, or
+- the *unqualified-id* is the *postfix-expression* in a dependent call.
+[*Note 1*: Such names are looked up only at the point of the template
+instantiation [[temp.point]] in both the context of the template
+definition and the context of the point of instantiation
 [[temp.dep.candidate]]. — *end note*]
 [*Example 1*:
 ``` cpp
 The base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</a>
+A name or *template-id* refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
   of a class template, the injected-class-name [[class.pre]] of the
   class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
+  template argument list of its *template-head* [[temp.arg]] enclosed in
+  `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
   or
+- in the definition of a class template partial specialization or a
+ member of a class template partial specialization, the name of the
+ class template followed by a template argument list equivalent to that
+ of the partial specialization [[temp.spec.partial]] enclosed in `<>`
+ (or an equivalent template alias specialization).
 A template argument that is equivalent to a template parameter can be
 used in place of that template parameter in a reference to the current
 instantiation. For a template *type-parameter*, a template argument is
 equivalent to a template parameter if it denotes the same type. For a
 — *end example*]
 — *end note*]
+A qualified [[basic.lookup.qual]] or unqualified name is a *member of
+the current instantiation* if
+- its lookup context, if it is a qualified name, is the current
+  instantiation, and
+- lookup for it finds any member of a class that is the current
+ instantiation
 [*Example 3*:
 ``` cpp
 template <class T> class A {
 }
 ```
 — *end example*]
+A qualified or unqualified name names a *dependent member of the current
+instantiation* if it is a member of the current instantiation that, when
+looked up, refers to at least one member declaration (including a
+*using-declarator* whose terminal name is dependent) of a class that is
+the current instantiation.
+A qualified name [[basic.lookup.qual]] is dependent if
+- it is a *conversion-function-id* whose *conversion-type-id* is
+  dependent, or
+- its lookup context is dependent and is not the current instantiation,
+ or
+- its lookup context is the current instantiation and it is
+ `operator=`,[^11] or
+- its lookup context is the current instantiation and has at least one
+  dependent base class, and qualified name lookup for the name finds
+ nothing [[basic.lookup.qual]].
 [*Example 4*:
 ``` cpp
+struct A {
+ using B = int;
+ A f();
 };
+struct C : A {};
+template<class T>
+void g(T t) {
+  decltype(t.A::f())::B i;      // error: typename needed to interpret B as a type
+}
+template void g(C);             // … even though A is ::A here
 ```
 — *end example*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
+instantiation with a qualified name, the name is looked up in the
+template instantiation context. If the result of this lookup differs
+from the result of name lookup in the template definition context, name
+lookup is ambiguous.
 [*Example 5*:
 ``` cpp
 struct A {
   int f() { return this->m; }   // finds A::m in the template definition context
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
+template int C<B>::g();         // OK, transformation to class member access syntax
+                                // does not occur in the template definition context; see~[class.mfct.non.static]
 ```
 — *end example*]
 A type is dependent if it is
 - a template parameter,
+- denoted by a dependent (qualified) name,
+- a nested class or enumeration that is a direct member of a class that
+ is the current instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
+- a function type whose parameters include one or more function
+  parameter packs,
 - a function type whose exception specification is value-dependent,
 - denoted by a *simple-template-id* in which either the template name is
   a template parameter or any of the template arguments is a dependent
   type or an expression that is type-dependent or value-dependent or is
+  a pack expansion,[^12] or
 - denoted by `decltype(`*expression*`)`, where *expression* is
   type-dependent [[temp.dep.expr]].
+[*Note 3*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
+`this` is type-dependent if the current class [[expr.prim.this]] is
 dependent [[temp.dep.type]].
+An *id-expression* is type-dependent if it is a *template-id* that is
+not a concept-id and is dependent; or if its terminal name is
+- associated by name lookup with one or more declarations declared with
+  a dependent type,
+- associated by name lookup with a non-type *template-parameter*
+  declared with a type that contains a placeholder type
+  [[dcl.spec.auto]],
+- associated by name lookup with a variable declared with a type that
+  contains a placeholder type [[dcl.spec.auto]] where the initializer is
   type-dependent,
+- associated by name lookup with one or more declarations of member
+  functions of a class that is the current instantiation declared with a
+  return type that contains a placeholder type,
+- associated by name lookup with a structured binding declaration
+  [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
+  type-dependent,
+- associated by name lookup with an entity captured by copy
+  [[expr.prim.lambda.capture]] in a *lambda-expression* that has an
+  explicit object parameter whose type is dependent [[dcl.fct]],
 - the *identifier* `__func__` [[dcl.fct.def.general]], where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
 - a *conversion-function-id* that specifies a dependent type, or
+- dependent
 or if it names a dependent member of the current instantiation that is a
 static data member of type “array of unknown bound of `T`” for some `T`
 [[temp.static]]. Expressions of the following forms are type-dependent
+only if the type specified by the *type-id*, *simple-type-specifier*,
+*typename-specifier*, or *new-type-id* is dependent, even if any
+subexpression is type-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
+simple-type-specifier braced-init-list
+typename-specifier '(' expression-listₒₚₜ ')'
+typename-specifier braced-init-list
 '::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
 '::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
 dynamic_cast '<' type-id '>' '(' expression ')'
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 A class member access expression [[expr.ref]] is type-dependent if the
+terminal name of its *id-expression*, if any, is dependent or the
 expression refers to a member of the current instantiation and the type
+of the referenced member is dependent.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to a
 dependent type that is not the current instantiation, the type of `y` is
+always dependent. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
 Furthermore, a non-type *template-argument* is dependent if the
 corresponding non-type *template-parameter* is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
+A template *template-parameter* is dependent if it names a
+*template-parameter* or its terminal name is dependent.
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
 different meanings according to the one-definition rule
 [[basic.def.odr]], the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
+If a dependent call [[temp.dep]] would be ill-formed or would find a
+better match had the lookup for its dependent name considered all the
+function declarations with external linkage introduced in the associated
+namespaces in all translation units, not just considering those
+declarations found in the template definition and template instantiation
+contexts [[basic.lookup.argdep]], then the program is ill-formed, no
+diagnostic required.
 [*Example 1*:
 Source file \`"X.h"\`
 module;
 #include "X.h"
 export module M;
 import F;
 void g(X x) {
+  f(x);             // OK, instantiates f from F,
                     // operator+ is visible in instantiation context
 }
 ```
 — *end example*]
 }
 ```
 — *end example*]
 ## Template instantiation and specialization <a id="temp.spec">[[temp.spec]]</a>
+### General <a id="temp.spec.general">[[temp.spec.general]]</a>
 The act of instantiating a function, a variable, a class, a member of a
 class template, or a member template is referred to as *template
 instantiation*.
 A function instantiated from a function template is called an
 An explicit specialization may be declared for a function template, a
 variable template, a class template, a member of a class template, or a
 member template. An explicit specialization declaration is introduced by
 `template<>`. In an explicit specialization declaration for a variable
+template, a class template, a member of a class template, or a class
+member template, the variable or class that is explicitly specialized
+shall be specified with a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
+template, the function or member function explicitly specialized may be
+specified using a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct A {
   program,
 - an explicit specialization shall be defined at most once in a program,
   as specified in [[basic.def.odr]], and
 - both an explicit instantiation and a declaration of an explicit
   specialization shall not appear in a program unless the explicit
+ specialization is reachable from the explicit instantiation.
+An implementation is not required to diagnose a violation of this rule
+if neither declaration is reachable from the other.
 The usual access checking rules do not apply to names in a declaration
 of an explicit instantiation or explicit specialization, with the
 exception of names appearing in a function body, default argument,
+*base-clause*, *member-specification*, *enumerator-list*, or static data
 member or variable template initializer.
 [*Note 1*: In particular, the template arguments and names used in the
 function declarator (including parameter types, return types and
+exception specifications) can be private types or objects that would
 normally not be accessible. — *end note*]
 Each class template specialization instantiated from a template has its
 own copy of any static members.
 }
 ```
 — *end example*]
+If the template selected for the specialization
+[[temp.spec.partial.match]] has been declared, but not defined, at the
+point of instantiation [[temp.point]], the instantiation yields an
+incomplete class type [[term.incomplete.type]].
 [*Example 2*:
 ``` cpp
 template<class T> class X;
 — *end example*]
 However, for the purpose of determining whether an instantiated
 redeclaration is valid according to  [[basic.def.odr]] and
+[[class.mem]], an instantiated declaration that corresponds to a
+definition in the template is considered to be a definition.
 [*Example 4*:
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
   template<class Y> struct Inner<T, Y>;         // #1a
+  template<class Y> struct Inner<T, Y> { };     // #1b; OK, valid redeclaration of #1a
   template<class Y> struct Inner<U, Y> { };     // #2
 };
 Outer<int, int> outer;                          // error at #2
 ```
 Friendly<float> ff;                             // error: produces second definition of f(U)
 ```
 — *end example*]
+Unless a member of a templated class is a declared specialization, the
+specialization of the member is implicitly instantiated when the
+specialization is referenced in a context that requires the member
+definition to exist or if the existence of the definition of the member
+affects the semantics of the program; in particular, the initialization
+(and any associated side effects) of a static data member does not occur
+unless the static data member is itself used in a way that requires the
+definition of the static data member to exist.
 Unless a function template specialization is a declared specialization,
 the function template specialization is implicitly instantiated when the
 specialization is referenced in a context that requires a function
 definition to exist or if the existence of the definition affects the
 context that requires the value of the default argument.
 [*Note 4*: An inline function that is the subject of an explicit
 instantiation declaration is not a declared specialization; the intent
 is that it still be implicitly instantiated when odr-used
+[[term.odr.use]] so that the body can be considered for inlining, but
 that no out-of-line copy of it be generated in the translation
 unit. — *end note*]
 [*Example 5*:
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated [[temp.over]].
 An implementation shall not implicitly instantiate a function template,
 a variable template, a member template, a non-virtual member function, a
+member class or static data member of a templated class, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
 instantiation is required.
 [*Note 5*: The instantiation of a generic lambda does not require
 instantiation of substatements of a constexpr if statement within its
 instantiated. — *end note*]
 It is unspecified whether or not an implementation implicitly
 instantiates a virtual member function of a class template if the
 virtual member function would not otherwise be instantiated. The use of
+a template specialization in a default argument or default member
+initializer shall not cause the template to be implicitly instantiated
+except where needed to determine the correctness of the default argument
+or default member initializer. The use of a default argument in a
 function call causes specializations in the default argument to be
+implicitly instantiated. Similarly, the use of a default member
+initializer in a constructor definition or an aggregate initialization
+causes specializations in the default member initializer to be
+instantiated.
+If a templated function `f` is called in a way that requires a default
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
 function template `f` used at that point, except that the scope in which
+a closure type is declared [[expr.prim.lambda.closure]] — and therefore
+its associated namespaces — remain as determined from the context of the
 definition for the default argument. This analysis is called *default
 argument instantiation*. The instantiated default argument is then used
 as the argument of `f`.
 Each default argument is instantiated independently.
+[*Example 8*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
 There is an *implementation-defined* quantity that specifies the limit
 on the total depth of recursive instantiations [[implimits]], which
 could involve more than one template. The result of an infinite
 recursion in instantiation is undefined.
+[*Example 9*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
 [*Note 7*: The satisfaction of constraints is determined during
 template argument deduction [[temp.deduct]] and overload resolution
 [[over.match]]. — *end note*]
+[*Example 10*:
 ``` cpp
 template<typename T> concept C = sizeof(T) > 2;
 template<typename T> concept D = C<T> && sizeof(T) > 4;
 the implicit declaration of a default constructor for `S<char>`
 [[class.default.ctor]], so there is no viable constructor for `s1`.
 — *end example*]
+[*Example 11*:
 ``` cpp
 template<typename T> struct S1 {
   template<typename U>
     requires false
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
 *simple-template-id*; otherwise, the *declaration* shall be a
 *simple-declaration* whose *init-declarator-list* comprises a single
 *init-declarator* that does not have an *initializer*. If the explicit
+instantiation is for a variable template specialization, the
+*unqualified-id* in the *declarator* shall be a *simple-template-id*.
 [*Example 1*:
 ``` cpp
 template<class T> class Array { void mf(); };
 template void N::f<int>(int&);
 ```
 — *end example*]
+An explicit instantiation does not introduce a name
+[[basic.scope.scope]]. A declaration of a function template, a variable
+template, a member function or static data member of a class template,
+or a member function template of a class or class template shall be
+reachable from any explicit instantiation of that entity. A definition
+of a class template, a member class of a class template, or a member
+class template of a class or class template shall be reachable from any
+explicit instantiation of that entity unless an explicit specialization
+of the entity with the same template arguments is reachable therefrom.
+If the *declaration* of the explicit instantiation names an
+implicitly-declared special member function [[special]], the program is
+ill-formed.
 The *declaration* in an *explicit-instantiation* and the *declaration*
 produced by the corresponding substitution into the templated function,
 variable, or class are two declarations of the same entity.
+[*Note 1*:
 These declarations are required to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
 an explicit instantiation definition, the definition of a function
 template, a variable template, a member function template, or a member
 function or static data member of a class template shall be present in
 every translation unit in which it is explicitly instantiated.
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
+function template specialization provided it can be deduced
+[[temp.deduct.decl]]. If all template arguments can be deduced, the
+empty template argument list `<>` may be omitted.
+[*Example 3*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
 template void sort<>(Array<int>&);
 ```
 — *end example*]
+[*Note 2*: An explicit instantiation of a constrained template is
 required to satisfy that template’s associated constraints
 [[temp.constr.decl]]. The satisfaction of constraints is determined when
 forming the template name of an explicit instantiation in which all
 template arguments are specified [[temp.names]], or, for explicit
 instantiations of function templates, during template argument deduction
 [[temp.deduct.decl]] when one or more trailing template arguments are
 left unspecified. — *end note*]
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
+definition) of each of its direct non-template members that has not been
 previously explicitly specialized in the translation unit containing the
 explicit instantiation, provided that the associated constraints, if
 any, of that member are satisfied by the template arguments of the
+explicit instantiation [[temp.constr.decl]], [[temp.constr.constr]],
 except as described below.
+[*Note 3*: In addition, it will typically be an explicit instantiation
 of certain implementation-dependent data about the class. — *end note*]
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
 An explicit instantiation of a prospective destructor [[class.dtor]]
+shall correspond to the selected destructor of the class.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
 also used in a way that would otherwise cause an implicit instantiation
 [[temp.inst]] in the translation unit shall be the subject of an
 explicit instantiation definition somewhere in the program; otherwise
 the program is ill-formed, no diagnostic required.
+[*Note 4*: This rule does apply to inline functions even though an
 explicit instantiation declaration of such an entity has no other
 normative effect. This is needed to ensure that if the address of an
 inline function is taken in a translation unit in which the
 implementation chose to suppress the out-of-line body, another
 translation unit will supply the body. — *end note*]
 a template with internal linkage.
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
+[*Example 4*:
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
 — *end example*]
+The *declaration* in an *explicit-specialization* shall not be an
+*export-declaration*. An explicit specialization shall not use a
+*storage-class-specifier* [[dcl.stc]] other than `thread_local`.
 An explicit specialization may be declared in any scope in which the
+corresponding primary template may be defined
+[[dcl.meaning]], [[class.mem]], [[temp.mem]].
+An explicit specialization does not introduce a name
+[[basic.scope.scope]]. A declaration of a function template, class
+template, or variable template being explicitly specialized shall be
+reachable from the declaration of the explicit specialization.
 [*Note 1*: A declaration, but not a definition of the template is
 required. — *end note*]
+The definition of a class or class template shall be reachable from the
 declaration of an explicit specialization for a member template of the
 class or class template.
 [*Example 2*:
 ``` cpp
 template<> class X<int> { ... };          // error: X not a template
 template<class T> class X;
+template<> class X<char*> { ... };        // OK, X is a template
 ```
 — *end example*]
 A member function, a member function template, a member class, a member
 enumeration, a member class template, a static data member, or a static
 data member template of a class template may be explicitly specialized
 for a class specialization that is implicitly instantiated; in this
+case, the definition of the class template shall be reachable from the
+explicit specialization for the member of the class template. If such an
+explicit specialization for the member of a class template names an
 implicitly-declared special member function [[special]], the program is
 ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
+explicitly defined if its definition is required. The definition of the
+class template explicit specialization shall be reachable from the
+definition of any member of it. The definition of an explicitly
+specialized class is unrelated to the definition of a generated
+specialization. That is, its members need not have the same names,
+types, etc. as the members of a generated specialization. Members of an
+explicitly specialized class template are defined in the same manner as
+members of normal classes, and not using the `template<>` syntax. The
+same is true when defining a member of an explicitly specialized member
+class. However, `template<>` is used in defining a member of an
+explicitly specialized member class template that is specialized as a
+class template.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
 ```
 — *end example*]
 If a template, a member template or a member of a class template is
+explicitly specialized, a declaration of that specialization shall be
+reachable from every use of that specialization that would cause an
+implicit instantiation to take place, in every translation unit in which
+such a use occurs; no diagnostic is required. If the program does not
+provide a definition for an explicit specialization and either the
+specialization is used in a way that would cause an implicit
+instantiation to take place or the member is a virtual member function,
+the program is ill-formed, no diagnostic required. An implicit
+instantiation is never generated for an explicit specialization that is
+declared but not defined.
 [*Example 4*:
 ``` cpp
 class String { };
 void f(Array<String>& v) {
   sort(v);          // use primary template sort(Array<T>&), T is String
 }
 template<> void sort<String>(Array<String>& v);     // error: specialization after use of primary template
+template<> void sort<>(Array<char*>& v);            // OK, sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
 template<> enum A<int>::E : int { eint };           // OK
 positioning of the explicit specialization declarations and their points
 of instantiation in the translation unit as specified above and below.
 When writing a specialization, be careful about its location; or to make
 it compile will be such a trial as to kindle its self-immolation.
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes
 [[basic.types]].
+[*Example 5*:
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> class X<int>;
+X<int>* p;                                      // OK, pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
+provided it can be deduced [[temp.deduct.decl]].
+[*Example 6*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v);
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
 specialization [[temp.fct]].
 Whether an explicit specialization of a function or variable template is
+inline, constexpr, constinit, or consteval is determined by the explicit
+specialization and is independent of those properties of the template.
+Similarly, attributes appearing in the declaration of a template have no
+effect on an explicit specialization of that template.
+[*Example 7*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
+template<> inline void f<>(int) { ... }   // OK, inline
+template<> int g<>(int) { ... }           // OK, not inline
+template<typename> [[noreturn]] void h([[maybe_unused]] int i);
+template<> void h<int>(int i) {
+    // Implementations are expected not to warn that the function returns
+    // but can warn about the unused parameter.
+}
 ```
 — *end example*]
 An explicit specialization of a static data member of a template or an
 if the declaration includes an initializer; otherwise, it is a
 declaration.
 [*Note 3*:
+The definition of a static data member of a template for which
+default-initialization is desired can use functional cast notation
+[[expr.type.conv]]:
 ``` cpp
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
+template<> X Q<int>::x = X(); // definition
 ```
 — *end note*]
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
+[*Example 8*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
+[*Example 9*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
 types of the *template-parameter*s in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
+[*Example 10*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
   specialization belongs is implicitly instantiated. \[*Note 4*: Default
+  function arguments can be specified in the declaration or definition
   of a member function of a class template specialization that is
   explicitly specialized. — *end note*]
 ## 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