[temp] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp74nppxtx/{from.md → to.md} +1287 -599

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

@@ -48,10 +48,11 @@ The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
 - be a *deduction-guide*, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A declaration introduced by
 a template declaration of a variable is a *variable template*. A
@@ -90,11 +91,11 @@ 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
@@ -104,24 +105,46 @@ 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
- templated entity,
 - 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.
@@ -147,11 +170,11 @@ unevaluated operand [[expr.context]].
 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*.
-[*Example 2*:
 ``` cpp
 template<int N> requires N == sizeof new unsigned short
 int f();            // error: parentheses required around == expression
 ```
@@ -173,20 +196,21 @@ The syntax for *template-parameter*s is:
 ``` bnf
 template-parameter:
   type-parameter
   parameter-declaration
 ```
 ``` bnf
 type-parameter:
   type-parameter-key '...'ₒₚₜ identifierₒₚₜ
   type-parameter-key identifierₒₚₜ '=' type-id
   type-constraint '...'ₒₚₜ identifierₒₚₜ
   type-constraint identifierₒₚₜ '=' type-id
-  template-head type-parameter-key '...'ₒₚₜ identifierₒₚₜ
-  template-head type-parameter-key identifierₒₚₜ '=' id-expression
 ```
 ``` bnf
 type-parameter-key:
   class
@@ -197,83 +221,150 @@ type-parameter-key:
 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 { ... };
 int i;
 template<class T, T i> void f(T t) {
-  T t1 = i;         // template-parameters T and i
   ::T t2 = ::i;     // global namespace members T and i
 }
 ```
-Here, the template `f` has a *type-parameter* called `T`, rather than an
-unnamed non-type *template-parameter* of class `T`.
 — *end example*]
-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 { ... };
-template<class K, class V, template<class T> class C = myarray>
-class Map {
-  C<K> key;
-  C<V> value;
-};
-```
-— *end note*]
 A *type-constraint* `Q` that designates a concept `C` can be used to
 constrain a contextually-determined type or template type parameter pack
 `T` with a *constraint-expression* `E` defined as follows. If `Q` is of
-the form `C<A₁, ⋯, Aₙ>`, then let `E'` be `C<T, A₁, ⋯, Aₙ>`. Otherwise,
 let `E'` be `C<T>`. If `T` is not a pack, then `E` is `E'`, otherwise
 `E` is `(E' && ...)`. This *constraint-expression* `E` is called the
 *immediately-declared constraint* of `Q` for `T`. The concept designated
 by a *type-constraint* shall be a type concept [[temp.concept]].
 A *type-parameter* that starts with a *type-constraint* introduces the
 immediately-declared constraint of the *type-constraint* for the
 parameter.
-[*Example 2*:
 ``` cpp
 template<typename T> concept C1 = true;
 template<typename... Ts> concept C2 = true;
 template<typename T, typename U> concept C3 = true;
@@ -285,12 +376,12 @@ template<C3<int> T> struct s4;          // associates C3<T, int>
 template<C3<int>... T> struct s5;       // associates (C3<T, int> && ...)
 ```
 — *end example*]
-A non-type *template-parameter* shall have one of the following
-(possibly cv-qualified) types:
 - a structural type (see below),
 - a type that contains a placeholder type [[dcl.spec.auto]], or
 - a placeholder for a deduced class type [[dcl.type.class.deduct]].
@@ -302,66 +393,63 @@ A *structural type* is one of the following:
 - a scalar type, or
 - 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
-*template-parameter*. All such template parameters in the program of the
-same type with the same value denote the same template parameter object.
-A template parameter object shall have constant destruction
-[[expr.const]].
-[*Note 3*: If an *id-expression* names a non-type non-reference
-*template-parameter*, then it is a prvalue if it has non-class type.
 Otherwise, if it is of class type `T`, it is an lvalue and has type
 `const T` [[expr.prim.id.unqual]]. — *end note*]
-[*Example 3*:
 ``` cpp
 using X = int;
 struct A {};
 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: 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*]
-[*Note 4*:
-A non-type *template-parameter* cannot be declared to have type cv
-`void`.
-[*Example 4*:
 ``` cpp
 template<void v> class X;       // error
 template<void* pv> class Y;     // OK
 ```
 — *end example*]
 — *end note*]
-A non-type *template-parameter* of type “array of `T`” or of function
-type `T` is adjusted to be of type “pointer to `T`”.
-[*Example 5*:
 ``` cpp
 template<int* a>   struct R { ... };
 template<int b[5]> struct S { ... };
 int p;
@@ -372,35 +460,35 @@ R<v> y;                         // OK due to implicit argument conversion
 S<v> z;                         // OK due to both adjustment and conversion
 ```
 — *end example*]
-A non-type template parameter declared with a type that contains a
 placeholder type with a *type-constraint* introduces the
 immediately-declared constraint of the *type-constraint* for the
 invented type corresponding to the placeholder [[dcl.fct]].
-A *default template-argument* is a *template-argument* [[temp.arg]]
-specified after `=` in a *template-parameter*. A default
-*template-argument* may be specified for any kind of
-*template-parameter* (type, non-type, template) that is not a template
-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]].
-[*Example 6*:
 ``` cpp
 template<class T1, class T2 = int> class A;
 template<class T1 = int, class T2> class A;
 ```
@@ -412,24 +500,25 @@ template<class T1 = int, class T2 = int> class A;
 ```
 — *end example*]
 If a *template-parameter* of a class template, variable template, or
-alias template has a default *template-argument*, each subsequent
-*template-parameter* shall either have a default *template-argument*
-supplied or be a template parameter pack. If a *template-parameter* of a
-primary class template, primary variable template, or alias template is
-a template parameter pack, it shall be the last *template-parameter*. A
-template parameter pack of a function template shall not be followed by
-another template parameter unless that template parameter can be deduced
-from the parameter-type-list [[dcl.fct]] of the function template or has
-a default argument [[temp.deduct]]. A template parameter of a deduction
 guide template [[temp.deduct.guide]] that does not have a default
 argument shall be deducible from the parameter-type-list of the
 deduction guide template.
-[*Example 7*:
 ``` cpp
 template<class T1 = int, class T2> class B;     // error
 // U can be neither deduced from the parameter-type-list nor specified
@@ -437,15 +526,15 @@ template<class... T, class... U> void f() { }   // error
 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 { ... };
@@ -454,15 +543,15 @@ class Y { ... };
 ```
 — *end example*]
 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();
@@ -475,39 +564,21 @@ template <template <class TT = char> class T> void A<T>::g() {
 }
 ```
 — *end example*]
-If a *template-parameter* is a *type-parameter* with an ellipsis prior
-to its optional *identifier* or is a *parameter-declaration* that
-declares a pack [[dcl.fct]], then the *template-parameter* is a template
-parameter pack [[temp.variadic]]. A template parameter pack that is a
-*parameter-declaration* whose type contains one or more unexpanded packs
-is a pack expansion. Similarly, a template parameter pack that is a
-*type-parameter* with a *template-parameter-list* containing one or more
-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 10*:
 ``` cpp
-template <class... Types>                       // Types is a template type parameter pack
-   class Tuple;                                 // but not a pack expansion
-template <class T, int... Dims>                 // Dims is a non-type template parameter pack
- struct multi_array;                          // but not a pack expansion
-template <class... T>
-  struct value_holder {
-    template <T... Values> struct apply { };    // Values is a non-type template parameter pack
-  };                                            // and a pack expansion
-template <class... T, T... Values>              // error: Values expands template type parameter
-  struct static_array;                          // pack T within the same template parameter list
 ```
 — *end example*]
 ## Names of template specializations <a id="temp.names">[[temp.names]]</a>
@@ -540,28 +611,34 @@ template-argument-list:
 ``` bnf
 template-argument:
   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*]
@@ -576,24 +653,30 @@ struct X {
 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
@@ -611,24 +694,40 @@ 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 {
   void f(int);
   template <class U> void f(U);
@@ -649,27 +748,29 @@ template <class T, template <class X> class TT = T::template C> struct D { };
 D<B<int> > db;
 ```
 — *end example*]
-A *template-id* is *valid* if
 - there are at most as many arguments as there are parameters or a
   parameter is a template parameter pack [[temp.variadic]],
 - there is an argument for each non-deducible non-pack parameter that
   does not have a default *template-argument*,
-- each *template-argument* matches the corresponding
- *template-parameter* [[temp.arg]],
 - substitution of each template argument into the following template
   parameters (if any) succeeds, and
-- if the *template-id* is non-dependent, the associated constraints are
- satisfied as specified in the next paragraph.
-A *simple-template-id* shall be valid unless it names a function
-template specialization [[temp.deduct]].
-[*Example 4*:
 ``` cpp
 template<class T, T::type n = 0> class X;
 struct S {
   using type = int;
@@ -681,18 +782,19 @@ using T4 = X<int>;              // error: substitution failure for second templa
 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*,
-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*:
 ``` cpp
 template<typename T> concept C1 = sizeof(T) != sizeof(int);
 template<C1 T> struct S1 { };
@@ -734,11 +836,11 @@ satisfied [[temp.constr.constr]] by the specified template arguments and
 [*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*:
 ``` cpp
 template<typename T> concept C = true;
 static_assert(C<int>);      // OK
 ```
@@ -747,18 +849,16 @@ static_assert(C<int>);      // OK
 ## 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
-parameter declared by the template is a template parameter pack
-[[temp.variadic]], it will correspond to zero or more
-*template-argument*s.
 [*Example 1*:
 ``` cpp
 template<class T> class Array {
@@ -790,11 +890,11 @@ 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*:
 ``` cpp
 template<class T> void f();
@@ -806,12 +906,13 @@ void g() {
 ```
 — *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 {
@@ -829,13 +930,13 @@ private:
 X<Y::S> y;          // error: S not accessible
 ```
 — *end example*]
-For a *template-argument* that is a class type or a class template, the
 template definition has no special access rights to the members of the
-*template-argument*.
 [*Example 4*:
 ``` cpp
 template <template <class TT> class T> class A {
@@ -850,11 +951,11 @@ private:
 A<B> b;             // error: A has no access to B::S
 ```
 — *end example*]
-When template argument packs or default *template-argument*s are used, a
 *template-argument* list can be empty. In that case the empty `<>`
 brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
@@ -885,25 +986,26 @@ void f(A<int>* p, A<int>* q) {
 }
 ```
 — *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.
 [*Example 7*:
 ``` cpp
 template<typename T, typename U = int> struct S { };
@@ -916,14 +1018,14 @@ The default argument for `U` is instantiated to form the type
 — *end example*]
 A *template-argument* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
-### Template type arguments <a id="temp.arg.type">[[temp.arg.type]]</a>
-A *template-argument* for a *template-parameter* which is a type shall
-be a *type-id*.
 [*Example 1*:
 ``` cpp
 template <class T> class X { };
@@ -947,45 +1049,92 @@ void f() {
 — *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
-type [[dcl.type.class.deduct]], the type of the parameter is the type
-deduced for the variable `x` in the invented declaration
 ``` cpp
-T x = template-argument ;
 ```
-If a deduced parameter type is not permitted for a *template-parameter*
-declaration [[temp.param]], the program is ill-formed.
-A *template-argument* for a non-type *template-parameter* shall be a
-converted constant expression [[expr.const]] of the type of the
-*template-parameter*.
-[*Note 1*: If the *template-argument* is an overload set (or the
-address of such, including forming a pointer-to-member), the matching
-function is selected from the set [[over.over]]. — *end note*]
-For a non-type *template-parameter* of reference or pointer type, or for
-each non-static data member of reference or pointer type in a non-type
-*template-parameter* of class type or subobject thereof, the reference
-or pointer value shall not refer to or be the address of (respectively):
 - a temporary object [[class.temporary]],
 - a string literal object [[lex.string]],
 - the result of a `typeid` expression [[expr.typeid]],
 - a predefined `__func__` variable [[dcl.fct.def.general]], or
 - a subobject [[intro.object]] of one of the above.
 [*Example 1*:
 ``` cpp
 template<const int* pci> struct X { ... };
 int ai[10];
 X<ai> xi;                       // array to pointer and qualification conversions
@@ -1008,20 +1157,35 @@ A<&f> a;                        // selects f(int)
 template<auto n> struct B { ... };
 B<5> b1;                        // OK, template parameter type is int
 B<'a'> b2;                      // OK, template parameter type is char
 B<2.5> b3;                      // OK, template parameter type is double
 B<void(0)> b4;                  // error: template parameter type cannot be void
 ```
 — *end example*]
 [*Note 2*:
 A *string-literal* [[lex.string]] is not an acceptable
-*template-argument* for a *template-parameter* of non-class type.
-[*Example 2*:
 ``` cpp
 template<class T, T p> class X {
   ...
 };
@@ -1044,13 +1208,13 @@ X<A, "Pyrophoricity"> z;        // OK, string-literal is a constructor argument
 — *end note*]
 [*Note 3*:
 A temporary object is not an acceptable *template-argument* when the
-corresponding *template-parameter* has reference type.
-[*Example 3*:
 ``` cpp
 template<const int& CRI> struct B { ... };
 B<1> b1;                        // error: temporary would be required for template argument
@@ -1069,21 +1233,23 @@ C<Y{X{1}.n}> c;                 // error: subobject of temporary object used to
 — *end note*]
 ### 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*:
@@ -1102,26 +1268,34 @@ C<A> c;             // V<int> within C<A> uses the primary template, so c.y.x ha
                     // V<int*> within C<A> uses the partial specialization, so c.z.x has type long
 ```
 — *end example*]
-A *template-argument* matches a template *template-parameter* `P` when
-`P` is at least as specialized as the *template-argument* `A`. In this
-comparison, if `P` is unconstrained, the constraints on `A` are not
-considered. If `P` contains a template parameter pack, then `A` also
-matches `P` if each of `A`’s template parameters matches the
-corresponding template parameter in the *template-head* of `P`. Two
-template parameters match if they are of the same kind (type, non-type,
-template), for non-type *template-parameter*s, their types are
-equivalent [[temp.over.link]], and for template *template-parameter*s,
-each of their corresponding *template-parameter*s matches, recursively.
-When `P`’s *template-head* contains a template parameter pack
-[[temp.variadic]], the template parameter pack will match zero or more
-template parameters or template parameter packs in the *template-head*
-of `A` with the same type and form as the template parameter pack in `P`
-(ignoring whether those template parameters are template parameter
-packs).
 [*Example 2*:
 ``` cpp
 template<class T> class A { ... };
@@ -1183,11 +1357,11 @@ S<Y> s2;            // error: P is not at least as specialized as Y
 S<Z> s3;            // OK, P is at least as specialized as Z
 ```
 — *end example*]
-A template *template-parameter* `P` is at least as specialized as a
 template *template-argument* `A` if, given the following rewrite to two
 function templates, the function template corresponding to `P` is at
 least as specialized as the function template corresponding to `A`
 according to the partial ordering rules for function templates
 [[temp.func.order]]. Given an invented class template `X` with the
@@ -1197,15 +1371,15 @@ according to the partial ordering rules for function templates
 - Each of the two function templates has the same template parameters
   and *requires-clause* (if any), respectively, as `P` or `A`.
 - Each function template has a single function parameter whose type is a
   specialization of `X` with template arguments corresponding to the
   template parameters from the respective function template where, for
-  each template parameter `PP` in the *template-head* of the function
-  template, a corresponding template argument `AA` is formed. If `PP`
   declares a template parameter pack, then `AA` is the pack expansion
-  `PP...` [[temp.variadic]]; otherwise, `AA` is the *id-expression*
-  `PP`.
 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>
@@ -1222,16 +1396,18 @@ by their associated constraints [[temp.constr.order]]. — *end note*]
 #### 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:
 - conjunctions [[temp.constr.op]],
-- disjunctions [[temp.constr.op]], and
-- atomic constraints [[temp.constr.atomic]].
 In order for a constrained template to be instantiated [[temp.spec]],
 its associated constraints [[temp.constr.decl]] shall be satisfied as
 described in the following subclauses.
@@ -1410,11 +1586,12 @@ void h2() {
 — *end note*]
 To determine if an atomic constraint is *satisfied*, the parameter
 mapping and template arguments are first substituted into its
-expression. If substitution results in an invalid type or expression,
 the constraint is not satisfied. Otherwise, the lvalue-to-rvalue
 conversion [[conv.lval]] is performed if necessary, and `E` shall be a
 constant expression of type `bool`. The constraint is satisfied if and
 only if evaluation of `E` results in `true`. If, at different points in
 the program, the satisfaction result is different for identical atomic
@@ -1441,10 +1618,93 @@ void g() {
                                 // call is ill-formed even though #2 is a better match
 ```
 — *end example*]
 ### Constrained declarations <a id="temp.constr.decl">[[temp.constr.decl]]</a>
 A template declaration [[temp.pre]] or templated function declaration
 [[dcl.fct]] can be constrained by the use of a *requires-clause*. This
 allows the specification of constraints for that declaration as an
@@ -1555,16 +1815,24 @@ The *normal form* of an *expression* `E` is a constraint
 - The normal form of an expression `( E )` is the normal form of `E`.
 - The normal form of an expression `E1 || E2` is the disjunction
   [[temp.constr.op]] of the normal forms of `E1` and `E2`.
 - The normal form of an expression `E1 && E2` is the conjunction of the
   normal forms of `E1` and `E2`.
-- The normal form of a concept-id `C<A₁, A₂, ..., Aₙ>` is the normal
- form of the *constraint-expression* of `C`, after substituting
-  `A₁, A₂, ..., Aₙ` for `C`'s respective template parameters in the
- parameter mappings in each atomic constraint. If any such substitution
- results in an invalid type or expression, the program is ill-formed;
-  no diagnostic is required.
   \[*Example 1*:
   ``` cpp
   template<typename T> concept A = T::value || true;
   template<typename U> concept B = A<U*>;
   template<typename V> concept C = B<V&>;
@@ -1575,10 +1843,35 @@ The *normal form* of an *expression* `E` is a constraint
   mapping), despite the expression `T::value` being ill-formed for a
   pointer type `T`. Normalization of `C`'s *constraint-expression*
   results in the program being ill-formed, because it would form the
   invalid type `V&*` in the parameter mapping.
   — *end example*]
 - The normal form of any other expression `E` is the atomic constraint
   whose expression is `E` and whose parameter mapping is the identity
   mapping.
 The process of obtaining the normal form of a *constraint-expression* is
@@ -1609,27 +1902,95 @@ The associated constraints of \#2 are `requires { typename T::type; }`
 The associated constraints of \#3 are `requires (T x) { ++x; }` (with
 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}$,
-  and
 - an atomic constraint A subsumes another atomic constraint B if and
   only if A and B are identical using the rules described in
-  [[temp.constr.atomic]].
 [*Example 1*: Let A and B be atomic constraints [[temp.constr.atomic]].
 The constraint A ∧ B subsumes A, but A does not subsume A ∧ B. The
 constraint A subsumes A ∨ B, but A ∨ B does not subsume A. Also note
 that every constraint subsumes itself. — *end example*]
@@ -1647,14 +2008,17 @@ partial ordering is used to determine
   [[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
 - `D1` and `D2` are both constrained declarations and `D1`’s associated
-  constraints subsume those of `D2`; or
 - `D2` has no associated constraints.
 A declaration `D1` is *more constrained* than another declaration `D2`
 when `D1` is at least as constrained as `D2`, and `D2` is not at least
 as constrained as `D1`.
@@ -1676,20 +2040,49 @@ g(true);                        // selects #3 because C1<bool> is not satisfied
 g(0);                           // selects #4
 ```
 — *end example*]
 ## Type equivalence <a id="temp.type">[[temp.type]]</a>
 Two *template-id*s are the same if
 - their *template-name*s, *operator-function-id*s, or
   *literal-operator-id*s refer to the same template, and
 - their corresponding type *template-argument*s are the same type, and
-- their corresponding non-type *template-argument*s are
-  template-argument-equivalent (see below) after conversion to the type
- of the *template-parameter*, and
 - their corresponding template *template-argument*s refer to the same
   template.
 Two *template-id*s that are the same refer to the same class, function,
 or variable.
@@ -1698,21 +2091,24 @@ Two values are *template-argument-equivalent* if they are of the same
 type and
 - they are of integral type and their values are the same, or
 - they are of floating-point type and their values are identical, or
 - they are of type `std::nullptr_t`, or
-- they are of enumeration type and their values are the same,[^6] or
 - they are of pointer type and they have the same pointer value, or
 - they are of pointer-to-member type and they refer to the same class
   member or are both the null member pointer value, or
 - they are of reference type and they refer to the same object or
   function, or
 - they are of array type and their corresponding elements are
-  template-argument-equivalent,[^7] or
 - they are of union type and either they both have no active member or
   they have the same active member and their active members are
   template-argument-equivalent, or
 - they are of class type and their corresponding direct subobjects and
   reference members are template-argument-equivalent.
 [*Example 1*:
@@ -1753,10 +2149,19 @@ 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
@@ -1777,11 +2182,13 @@ 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>
@@ -1945,19 +2352,20 @@ v2[3] = dcomplex(7,8);                  // Array<dcomplex>::operator[]
 — *end example*]
 #### 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 ';'
 ```
 [*Example 1*:
 ``` cpp
@@ -1976,11 +2384,13 @@ S x{A()};           // x is of type S<short, int>
 ```
 — *end example*]
 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
@@ -2057,11 +2467,10 @@ class template definition.
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
-A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
 — *end example*]
@@ -2170,13 +2579,13 @@ class D : public B {
 — *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 {
@@ -2193,13 +2602,15 @@ int main() {
 }
 ```
 — *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>
@@ -2252,15 +2663,33 @@ foo();                          // xs contains zero init-captures
 foo(1);                         // xs contains one init-capture
 ```
 — *end example*]
-A *pack* is a template parameter pack, a function parameter pack, or an
-*init-capture* pack. The number of elements of a template parameter pack
-or a function parameter pack is the number of arguments provided for the
-parameter pack. The number of elements of an *init-capture* pack is the
-number of elements in the pack expansion of its *initializer*.
 A *pack expansion* consists of a *pattern* and an ellipsis, the
 instantiation of which produces zero or more instantiations of the
 pattern in a list (described below). The form of the pattern depends on
 the context in which the expansion occurs. Pack expansions can occur in
@@ -2268,15 +2697,21 @@ the following contexts:
 - In a function parameter pack [[dcl.fct]]; the pattern is the
   *parameter-declaration* without the ellipsis.
 - In a *using-declaration* [[namespace.udecl]]; the pattern is a
   *using-declarator*.
 - In a template parameter pack that is a pack expansion [[temp.param]]:
   - if the template parameter pack is a *parameter-declaration*; the
     pattern is the *parameter-declaration* without the ellipsis;
   - if the template parameter pack is a *type-parameter*; the pattern is
-    the corresponding *type-parameter* without the ellipsis.
 - In an *initializer-list* [[dcl.init]]; the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* [[class.derived]]; the pattern is a
   *base-specifier*.
 - In a *mem-initializer-list* [[class.base.init]] for a
@@ -2284,20 +2719,26 @@ the following contexts:
   pattern is the *mem-initializer*.
 - In a *template-argument-list* [[temp.arg]]; the pattern is a
   *template-argument*.
 - In an *attribute-list* [[dcl.attr.grammar]]; the pattern is an
   *attribute*.
 - In an *alignment-specifier* [[dcl.align]]; the pattern is the
   *alignment-specifier* without the ellipsis.
 - In a *capture-list* [[expr.prim.lambda.capture]]; the pattern is the
   *capture* without the ellipsis.
 - In a `sizeof...` expression [[expr.sizeof]]; the pattern is an
   *identifier*.
 - In a *fold-expression* [[expr.prim.fold]]; the pattern is the
   *cast-expression* that contains an unexpanded pack.
-[*Example 4*:
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
@@ -2317,11 +2758,11 @@ a pack expansion shall name one or more packs that are not expanded by a
 nested pack expansion; such packs are called *unexpanded packs* in the
 pattern. All of the packs expanded by a pack expansion shall have the
 same number of arguments specified. An appearance of a name of a pack
 that is not expanded is ill-formed.
-[*Example 5*:
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
@@ -2353,33 +2794,45 @@ The instantiation of a pack expansion considers items
 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$`))`
@@ -2391,11 +2844,11 @@ The instantiation of a *fold-expression* [[expr.prim.fold]] produces:
 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); }
@@ -2418,21 +2871,23 @@ If N is zero for a unary fold, the value of the expression is shown in
 | `&&`     | `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...);
@@ -2714,19 +3169,20 @@ A<int,int*> a;      // uses the partial specialization, which is found through t
                     // which refers to the 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
@@ -2737,11 +3193,11 @@ restrictions apply:
   — *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
@@ -3001,11 +3457,11 @@ 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.
@@ -3071,11 +3527,11 @@ template <int K, int L> A<K+L> f(A<K>, A<L>);   // same as #1
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
-[*Note 2*: Most expressions that use template parameters use non-type
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
@@ -3102,12 +3558,12 @@ 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
@@ -3163,34 +3619,35 @@ declared with a *type-constraint*, and if either *template-head* has a
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
-- if they declare non-type template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
-- if they declare template template parameters, their template
- parameters are equivalent.
 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.
 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
@@ -3240,20 +3697,24 @@ function type. The deduction process determines whether one of the
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
-To produce the transformed template, for each type, non-type, or
-template template parameter (including template parameter packs
-[[temp.variadic]] thereof) synthesize a unique type, value, or class
-template respectively and substitute it for each occurrence of that
-parameter in the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
-synthesized for a non-type template parameter is also a unique
 synthesized type. — *end note*]
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order
@@ -3457,14 +3918,21 @@ void h() {
 A *template-declaration* in which the *declaration* is an
 *alias-declaration* [[dcl.pre]] declares the *identifier* to be an
 *alias template*. An alias template is a name for a family of types. The
 name of the alias template is a *template-name*.
-When a *template-id* refers to the specialization of an alias template,
-it is equivalent to the associated type obtained by substitution of its
-*template-argument*s for the *template-parameter*s in the
-*defining-type-id* of the alias template.
 [*Note 1*: An alias template name is never deduced. — *end note*]
 [*Example 1*:
@@ -3589,11 +4057,11 @@ specialized [[temp.expl.spec]], or partially specialized
 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>
@@ -3682,11 +4150,11 @@ 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
@@ -3717,48 +4185,60 @@ void foo() {
 }
 ```
 — *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
 template<class T> struct S {
   using Ptr = PtrTraits<T>::Ptr;        // OK, in a defining-type-id
   T::R f(T::P p) {                      // OK, class scope
     return static_cast<T::R>(p);        // OK, type-id of a static_cast
   }
   auto g() -> S<T*>::Ptr;               // OK, trailing-return-type
 };
 template<typename T> void f() {
   void (*pf)(T::X);                     // variable pf of type void* initialized with T::X
   void g(T::X);                         // error: T::X at block scope does not denote a type
                                         // (attempt to declare a void variable)
@@ -3793,33 +4273,45 @@ int main() {
 }
 ```
 — *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:
@@ -3850,13 +4342,10 @@ This can happen in situations including the following:
   it names an explicit specialization that was not declared when the
   template was defined.
 — *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*:
@@ -3893,12 +4382,12 @@ considered definitions [[temp.decls]]. — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name [[class.pre]]. The injected-class-name can be used
 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 argument list
 [[temp.decls.general]], [[temp.arg.general]] of the class template
@@ -3982,26 +4471,26 @@ template<class T> class X {
 };
 ```
 — *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
@@ -4110,25 +4599,25 @@ A name or *template-id* refers to the *current instantiation* if it is
   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
-non-type template parameter, a template argument is equivalent to a
-template parameter if it is an *identifier* that names a variable that
-is equivalent to the template parameter. A variable is equivalent to a
-template parameter if
 - it has the same type as the template parameter (ignoring
   cv-qualification) and
 - its initializer consists of a single *identifier* that names the
   template parameter or, recursively, such a variable.
@@ -4240,11 +4729,11 @@ 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*:
@@ -4288,11 +4777,44 @@ struct C : A, T {
   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
@@ -4306,16 +4828,21 @@ A type is dependent if it is
 - 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*]
@@ -4331,29 +4858,57 @@ 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
@@ -4388,10 +4943,12 @@ typeid '(' expression ')'
 typeid '(' type-id ')'
 '::'ₒₚₜ delete cast-expression
 '::'ₒₚₜ delete '[' ']' cast-expression
 throw assignment-expressionₒₚₜ
 noexcept '(' expression ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
@@ -4409,21 +4966,30 @@ 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.
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, an expression used in a context where a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
-An *id-expression* is value-dependent if:
-- it is a concept-id and any of its arguments are dependent,
 - it is type-dependent,
-- it is the name of a non-type template parameter,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it names a potentially-constant variable [[expr.const]] that is
@@ -4437,58 +5003,158 @@ dependent:
 sizeof unary-expression
 sizeof '(' type-id ')'
 typeid '(' expression ')'
 typeid '(' type-id ')'
 alignof '(' type-id ')'
-noexcept '(' expression ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
-*type-id* or *simple-type-specifier* is dependent or the *expression* or
-*cast-expression* is value-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
 reinterpret_cast '<' type-id '>' '(' expression ')'
 '(' type-id ')' cast-expression
 ```
 Expressions of the following form are value-dependent:
 ``` bnf
 sizeof '...' '(' identifier ')'
 fold-expression
 ```
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
 expression [[expr.const]] succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
-A non-type *template-argument* is dependent if its type is dependent or
 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-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>
@@ -4558,10 +5224,16 @@ instantiation within a translation unit. A specialization for any
 template may have points of instantiation in multiple translation units.
 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>
 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
@@ -4795,13 +5467,12 @@ 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 {
@@ -5134,13 +5805,13 @@ void g(S<int>& sr) {
 };
 ```
 — *end example*]
-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 or static data member of a templated class, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
@@ -5195,18 +5866,18 @@ void g(A a, A b, A c) {
 }
 ```
 — *end example*]
-The *noexcept-specifier* of a function template specialization is not
-instantiated along with the function declaration; it is instantiated
-when needed [[except.spec]]. If such an *noexcept-specifier* is needed
 but has not yet been instantiated, the dependent names are looked up,
 the semantics constraints are checked, and the instantiation of any
-template used in the *noexcept-specifier* is done as if it were being
-done as part of instantiating the declaration of the specialization at
-that point.
 [*Note 6*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
@@ -5325,11 +5996,11 @@ instantiation is for a variable template specialization, the
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
 template<class T> void sort(Array<T>& v) { ... }
-template void sort(Array<char>&);       // argument is deduced here
 namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
@@ -5354,11 +6025,11 @@ 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*:
 ``` cpp
@@ -5366,11 +6037,11 @@ template<typename T> T var = {};
 template float var<float>;      // OK, instantiated variable has type float
 template int var<int[16]>[];    // OK, absence of major array bound is permitted
 template int *var<int>;         // error: instantiated variable has type int
 template<typename T> auto av = T();
-template int av<int>;           // OK, variable with type int can be redeclared with type auto
 template<typename T> auto f() {}
 template void f<int>();         // error: function with deduced return type
                                 // redeclared with non-deduced return type[dcl.spec.auto]
 ```
@@ -5390,36 +6061,18 @@ 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.
-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) { ... }
-// instantiate sort(Array<int>&) -- template-argument deduced
-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
@@ -5459,11 +6112,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 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.
@@ -5495,24 +6148,25 @@ explicit-specialization:
 [*Example 1*:
 ``` cpp
 template<class T> class stream;
-template<> class stream<char> { ... };
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
-template<> void sort<char*>(Array<char*>&);
 ```
-Given these declarations, `stream<char>` will be used as the definition
-of streams of `char`s; other streams will be handled by class template
-specializations instantiated from the class template. Similarly,
-`sort<char*>` will be used as the sort function for arguments of type
-`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
@@ -5526,11 +6180,11 @@ 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.
@@ -5676,13 +6330,14 @@ 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 *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
@@ -5693,47 +6348,33 @@ X<int>* p;                                      // OK, pointer to declared class
 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);
-// explicit specialization for sort(Array<int>&)
-// with deduced template-argument of type int
-template<> void sort(Array<int>&);
-```
-— *end example*]
-[*Note 2*: An explicit specialization 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 specialization in which all
-template arguments are specified [[temp.names]], or, for explicit
-specializations of function templates, during template argument
-deduction [[temp.deduct.decl]] when one or more trailing template
-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, 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) { ... }
@@ -5752,11 +6393,11 @@ template<> void h<int>(int i) {
 An explicit specialization of a static data member of a template or an
 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 for which
 default-initialization is desired can use functional cast notation
 [[expr.type.conv]]:
@@ -5772,11 +6413,11 @@ 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);
@@ -5808,11 +6449,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 9*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
@@ -5834,11 +6475,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 10*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
@@ -5870,11 +6511,11 @@ 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 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>
@@ -5999,14 +6640,14 @@ int l = f<>(1);                 // uses #1
 ```
 — *end note*]
 Template arguments that are present shall be specified in the
-declaration order of their corresponding *template-parameter*s. The
 template argument list shall not specify more *template-argument*s than
 there are corresponding *template-parameter*s unless one of the
-*template-parameter*s is a template parameter pack.
 [*Example 3*:
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
@@ -6022,11 +6663,11 @@ void g() {
 — *end example*]
 Implicit conversions [[conv]] will be performed on a function argument
 to convert it to the type of the corresponding function parameter if the
-parameter type contains no *template-parameter*s that participate in
 template argument deduction.
 [*Note 3*:
 Template parameters do not participate in template argument deduction if
@@ -6096,13 +6737,14 @@ void g(double d) {
 ```
 — *end example*]
 When an explicit template argument list is specified, if the given
-*template-id* is not valid [[temp.names]], type deduction fails.
-Otherwise, the specified template argument values are substituted for
-the corresponding template parameters as specified below.
 After this substitution is performed, the function parameter type
 adjustments described in  [[dcl.fct]] are performed.
 [*Example 2*: A parameter type of “`void (const int, int[5])`” becomes
@@ -6227,29 +6869,33 @@ when any template arguments that were deduced or obtained from default
 arguments are substituted.
 The *deduction substitution loci* are
 - the function type outside of the *noexcept-specifier*,
-- the *explicit-specifier*, and
-- the template parameter declarations.
 The substitution occurs in all types and expressions that are used in
 the deduction substitution loci. The expressions include not only
 constant expressions such as those that appear in array bounds or as
-nontype template arguments but also general expressions (i.e.,
 non-constant expressions) inside `sizeof`, `decltype`, and other
 contexts that allow non-constant expressions. The substitution proceeds
 in lexical order and stops when a condition that causes deduction to
 fail is encountered. If substitution into different declarations of the
 same function template would cause template instantiations to occur in a
 different order or not at all, the program is ill-formed; no diagnostic
 required.
-[*Note 4*: The equivalent substitution in exception specifications is
-done only when the *noexcept-specifier* is instantiated, at which point
-a program is ill-formed if the substitution results in an invalid type
-or expression. — *end note*]
 [*Example 6*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
@@ -6287,13 +6933,12 @@ effects such as the instantiation of class template specializations
 and/or function template specializations, the generation of
 implicitly-defined functions, etc. Such effects are not in the
 “immediate context” and can result in the program being
 ill-formed. — *end note*]
-A *lambda-expression* appearing in a function type or a template
-parameter is not considered part of the immediate context for the
-purposes of template argument deduction.
 [*Note 7*:
 The intent is to avoid requiring implementations to deal with
 substitution failure involving arbitrary statements.
@@ -6378,11 +7023,12 @@ Type deduction can fail for the following reasons:
   *qualified-id* when that type does not contain the specified member,
   or
   - the specified member is not a type where a type is required, or
   - the specified member is not a template where a template is required,
     or
-  - the specified member is not a non-type where a non-type is required.
   \[*Example 11*:
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
@@ -6400,11 +7046,11 @@ Type deduction can fail for the following reasons:
   int main() {
     // Deduction fails in each of these cases:
     f<A>(0);          // A does not contain a member Y
     f<B>(0);          // The Y member of B is not a type
-    g<C>(0);          // The N member of C is not a non-type
     h<D>(0);          // The TT member of D is not a template
   }
   ```
   — *end example*]
@@ -6417,19 +7063,19 @@ Type deduction can fail for the following reasons:
   template <class T> int f(int T::*);
   int i = f<int>(0);
   ```
   — *end example*]
-- Attempting to give an invalid type to a non-type template parameter.
   \[*Example 13*:
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T{}>*);   // #1
   class X {
     int m;
   };
-  int i0 = f<X>(0);   // #1 uses a value of non-structural type X as a non-type template argument
   ```
   — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
@@ -6442,10 +7088,13 @@ Type deduction can fail for the following reasons:
   — *end example*]
 - Attempting to create a function type in which a parameter has a type
   of `void`, or in which the return type is a function type or array
   type.
 — *end note*]
 [*Example 15*:
@@ -6465,23 +7114,23 @@ int i2 = f<1>(0);               // ambiguous; not narrowing
 — *end example*]
 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
-parameter type (call it `P`) that contains *template-parameter*s that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
-`std::initializer_list<P^{\prime}>` or `P`'`[N]` for some `P`' and `N`
-and the argument is a non-empty initializer list [[dcl.init.list]], then
-deduction is performed instead for each element of the initializer list
-independently, taking `P`' as separate function template parameter types
-`P`'_i and the iᵗʰ initializer element as the corresponding argument. In
-the `P`'`[N]` case, if `N` is a non-type template parameter, `N` is
-deduced from the length of the initializer list. Otherwise, an
-initializer list argument causes the parameter to be considered a
-non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
@@ -6619,19 +7268,20 @@ that allow a difference:
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
-- If `P` is a class and `P` has the form *simple-template-id*, then the
- transformed `A` can be a derived class `D` of the deduced `A`.
- Likewise, if `P` is a pointer to a class of the form
- *simple-template-id*, the transformed `A` can be a pointer to a
- derived class `D` pointed to by the deduced `A`. However, if there is
- a class `C` that is a (direct or indirect) base class of `D` and
- derived (directly or indirectly) from a class `B` and that would be a
- valid deduced `A`, the deduced `A` cannot be `B` or pointer to `B`,
- respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
@@ -6650,11 +7300,11 @@ that allow a difference:
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
-[*Note 1*: If a *template-parameter* is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
@@ -6663,14 +7313,14 @@ pointer-to-member-function type:
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
-  members of the set. If deduction succeeds for only one of the overload
- set members, that member is used as the argument value for the
- deduction. If deduction succeeds for more than one member of the
- overload set the parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
@@ -6704,10 +7354,26 @@ template <class T> T g(T);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
 #### Deducing template arguments taking the address of a function template <a id="temp.deduct.funcaddr">[[temp.deduct.funcaddr]]</a>
 Template arguments can be deduced from the type specified when taking
 the address of an overload set [[over.over]]. If there is a target, the
 function template’s function type and the target type are used as the
@@ -6787,11 +7453,11 @@ as the parameter template.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
-  parameter types for which the function call has arguments.[^13]
 - In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts [[temp.func.order]] the function template’s function
   type is used.
@@ -6914,13 +7580,13 @@ g(Tuple<int>());                // calls #3
 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
-value for a non-type parameter, or a template for a template parameter)
-that will make `P`, after substitution of the deduced values (call it
-the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
@@ -6930,52 +7596,57 @@ pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
 deduction fails. The type of a type parameter is only deduced from an
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
-templates, and non-type values:
 - A function type includes the types of each of the function parameters,
   the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
-  includes the types, templates, and non-type values referenced by the
-  template argument list of the specialization.
 - An array type includes the array element type and the value of the
   array bound.
-In most cases, the types, templates, and non-type values that are used
-to compose `P` participate in template argument deduction. That is, they
-may be used to determine the value of a template argument, and template
-argument deduction fails if the value so determined is not consistent
-with the values determined elsewhere. In certain contexts, however, the
-value does not participate in type deduction, but instead uses the
-values of template arguments that were either deduced elsewhere or
-explicitly specified. If a template parameter is used only in
-non-deduced contexts and is not explicitly specified, template argument
-deduction fails.
-[*Note 1*: Under [[temp.deduct.call]], if `P` contains no
-*template-parameter*s that appear in deduced contexts, no deduction is
-done, so `P` and `A` need not have the same form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - The *expression* of a *decltype-specifier*.
-- A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
 - A function parameter for which the associated argument is an overload
-  set [[over.over]], and one or more of the following apply:
-  - more than one function matches the function parameter type
     (resulting in an ambiguous deduction), or
-  - no function matches the function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
@@ -7084,13 +7755,15 @@ void t() {
 }
 ```
 — *end example*]
-A template type argument `T`, a template template argument `TT`, or a
-template non-type argument `i` can be deduced if `P` and `A` have one of
-the following forms:
 ``` cpp
 \opt{cv} T
 T*
 T&
@@ -7099,47 +7772,48 @@ T&&
 \opt{T}(\opt{T}) noexcept(\opt{i})
 \opt{T} \opt{T}::*
 \opt{TT}<T>
 \opt{TT}<i>
 \opt{TT}<TT>
 \opt{TT}<>
 ```
 where
 - `\opt{T}` represents a type or parameter-type-list that either
   satisfies these rules recursively, is a non-deduced context in `P` or
   `A`, or is the same non-dependent type in `P` and `A`,
-- `\opt{TT}` represents either a class template or a template template
-  parameter,
 - `\opt{i}` represents an expression that either is an `i`, is
   value-dependent in `P` or `A`, or has the same constant value in `P`
-  and `A`, and
 - `noexcept(\opt{i})` represents an exception specification
   [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
   *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
   above.
 [*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
 `TT`s, deduction is not possible. — *end note*]
-Similarly, `<T>` represents template argument lists where at least one
-argument contains a `T`, `<i>` represents template argument lists where
-at least one argument contains an `i` and `<>` represents template
-argument lists where no argument contains a `T` or an `i`.
-If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
-the respective template argument list of `P` is compared with the
-corresponding argument Aᵢ of the corresponding template argument list of
-`A`. If the template argument list of `P` contains a pack expansion that
-is not the last template argument, the entire template argument list is
-a non-deduced context. If `Pᵢ` is a pack expansion, then the pattern of
-`Pᵢ` is compared with each remaining argument in the template argument
-list of `A`. Each comparison deduces template arguments for subsequent
-positions in the template parameter packs expanded by `Pᵢ`. During
-partial ordering [[temp.deduct.partial]], if `Aᵢ` was originally a pack
-expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
@@ -7240,11 +7914,11 @@ where type is `X<int>` and `T` is `char[6]`.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
-When the value of the argument corresponding to a non-type template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
@@ -7331,12 +8005,12 @@ void g() {
 — *end note*]
 [*Note 5*:
-If, in the declaration of a function template with a non-type template
-parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 [*Example 12*:
@@ -7377,13 +8051,14 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 — *end note*]
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
-named by the enclosing *simple-template-id*, deduction fails. If `P` has
-a form that contains `[i]`, and if the type of `i` is not an integral
-type, deduction fails.[^14]
 If `P` has a form that includes `noexcept(i)` and the type of `i` is not
 `bool`, deduction fails.
 [*Example 13*:
@@ -7443,11 +8118,11 @@ void g() {
 }
 ```
 — *end example*]
-The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
 [*Example 16*:
@@ -7515,23 +8190,26 @@ 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; }
@@ -7556,11 +8234,11 @@ conversion of `char` to `int` for `c`.
 — *end example*]
 [*Example 2*:
 Here is an example involving conversions on a function argument involved
-in *template-argument* deduction:
 ``` cpp
 template<class T> struct B { ... };
 template<class T> struct D : public B<T> { ... };
 template<class T> void f(B<T>&);
@@ -7574,11 +8252,11 @@ void g(B<int>& bi, D<int>& di) {
 — *end example*]
 [*Example 3*:
 Here is an example involving conversions on a function argument not
-involved in *template-parameter* deduction:
 ``` cpp
 template<class T> void f(T*,int);       // #1
 template<class T> void f(T,char);       // #2
@@ -7622,10 +8300,11 @@ in some translation unit [[temp.pre]].
 [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
@@ -7633,10 +8312,11 @@ in some translation unit [[temp.pre]].
 [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
@@ -7645,28 +8325,33 @@ in some translation unit [[temp.pre]].
 [conv.func]: expr.md#conv.func
 [conv.lval]: expr.md#conv.lval
 [conv.qual]: expr.md#conv.qual
 [dcl.align]: dcl.md#dcl.align
 [dcl.attr.grammar]: dcl.md#dcl.attr.grammar
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.pre]: dcl.md#dcl.pre
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type.class.deduct]: dcl.md#dcl.type.class.deduct
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [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
@@ -7677,13 +8362,15 @@ in some translation unit [[temp.pre]].
 [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
@@ -7692,10 +8379,11 @@ in some translation unit [[temp.pre]].
 [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
@@ -7707,13 +8395,15 @@ in some translation unit [[temp.pre]].
 [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
@@ -7730,11 +8420,13 @@ in some translation unit [[temp.pre]].
 [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
@@ -7769,66 +8461,62 @@ in some translation unit [[temp.pre]].
 [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.
-[^2]: A `>` that encloses the *type-id* of a `dynamic_cast`,
     `static_cast`, `reinterpret_cast` or `const_cast`, or which encloses
-    the *template-argument*s of a subsequent *template-id*, is
-    considered nested for the purpose of this description.
-[^3]: There is no such ambiguity in a default *template-argument*
     because the form of the *template-parameter* determines the
     allowable forms of the *template-argument*.
-[^4]: A constraint is in disjunctive normal form when it is a
-    disjunction of clauses where each clause is a conjunction of atomic
-    constraints. 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

 - declare or define a function, a class, or a variable, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
+- be a *friend-type-declaration*, or
 - be a *deduction-guide*, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A declaration introduced by
 a template declaration of a variable is a *variable template*. A
 [*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
 [*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 *using-declarator*s, a type, 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.
+[*Example 2*:
+``` cpp
+void f() {}
+class f {};                                     // OK
+namespace N {
+  void f(int) {}
+}
+using N::f;                                     // OK
+template<typename> void f(long) {}              // #1, OK
+template<typename> void f(long) {}              // error: redefinition of #1
+template<typename> void f(long long) {}         // OK
+template<>         void f<int>(long long) {}    // OK, doesn't bind a name
+```
+— *end example*]
+— *end note*]
 An entity is *templated* if it is
 - a template,
+- an entity defined [[basic.def]] or created [[class.temporary]] within
+ the *compound-statement* of an *expansion-statement* [[stmt.expand]],
+- an entity defined or created in a templated entity,
 - 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.
 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*.
+[*Example 3*:
 ``` cpp
 template<int N> requires N == sizeof new unsigned short
 int f();            // error: parentheses required around == expression
 ```
 ``` bnf
 template-parameter:
   type-parameter
   parameter-declaration
+  type-tt-parameter
+  variable-tt-parameter
+  concept-tt-parameter
 ```
 ``` bnf
 type-parameter:
   type-parameter-key '...'ₒₚₜ identifierₒₚₜ
   type-parameter-key identifierₒₚₜ '=' type-id
   type-constraint '...'ₒₚₜ identifierₒₚₜ
   type-constraint identifierₒₚₜ '=' type-id
 ```
 ``` bnf
 type-parameter-key:
   class
 type-constraint:
   nested-name-specifierₒₚₜ concept-name
   nested-name-specifierₒₚₜ concept-name '<' template-argument-listₒₚₜ '>'
 ```
+``` bnf
+type-tt-parameter:
+  template-head type-parameter-key '...'ₒₚₜ identifierₒₚₜ
+  template-head type-parameter-key identifierₒₚₜ type-tt-parameter-default
+```
+``` bnf
+type-tt-parameter-default:
+  '=' nested-name-specifierₒₚₜ template-name
+  '=' nested-name-specifier 'template' template-name
+```
+``` bnf
+variable-tt-parameter:
+  template-head 'auto' '...'ₒₚₜ identifierₒₚₜ
+  template-head 'auto' identifierₒₚₜ '=' nested-name-specifierₒₚₜ template-name
+```
+``` bnf
+concept-tt-parameter:
+  'template' '<' template-parameter-list '>' 'concept' '...'ₒₚₜ identifierₒₚₜ
+  'template' '<' template-parameter-list '>' 'concept' identifierₒₚₜ '=' nested-name-specifierₒₚₜ template-name
+```
 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-tt-parameter*, *variable-tt-parameter*, or *concept-tt-parameter*
+can be the product of replacing a `>>` token by two consecutive `>`
+tokens [[temp.names]]. — *end note*]
+A template parameter is of one of the following kinds:
+- A *type template parameter* is a template parameter introduced by a
+  *type-parameter*.
+- A *constant template parameter* is a template parameter introduced by
+  a *parameter-declaration*.
+- A *type template template parameter* is a template parameter
+  introduced by a *type-tt-parameter*.
+- A *variable template template parameter* is a template parameter
+  introduced by a *variable-tt-parameter*.
+- A *concept template parameter* is a template parameter introduced by a
+  *concept-tt-parameter*.
+Type template template parameters, variable template template
+parameters, and concept template parameters are collectively referred to
+as *template template parameters*.
+The *nested-name-specifier* of a *type-constraint*, if any, shall not be
+dependent.
+A concept template parameter shall not have associated constraints
+[[temp.constr.decl]].
+If a *template-parameter* is a *parameter-declaration* that declares a
+pack [[dcl.fct]], or otherwise has an ellipsis prior to its optional
+*identifier*, then the *template-parameter* declares a template
+parameter pack [[temp.variadic]]. A template parameter pack that is a
+*parameter-declaration* whose type contains one or more unexpanded packs
+is a pack expansion. Similarly, a template parameter pack that is a
+template template parameter with a *template-parameter-list* containing
+one or more 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 1*:
+``` cpp
+template <class... Types>                       // Types is a template type parameter pack
+   class Tuple;                                 // but not a pack expansion
+template <class T, int... Dims>                 // Dims is a constant template parameter pack
+   struct multi_array;                          // but not a pack expansion
+template <class... T>
+  struct value_holder {
+    template <T... Values> struct apply { };    // Values is a constant template parameter pack
+  };                                            // and a pack expansion
+template <class... T, T... Values>              // error: Values expands template type parameter
+  struct static_array;                          // pack T within the same template parameter list
+```
+— *end example*]
 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 *parameter-declaration*. A *template-parameter* of the
+form `class` *identifier* is a *type-parameter*.
+[*Example 2*:
 ``` cpp
 class T { ... };
 int i;
 template<class T, T i> void f(T t) {
+  T t1 = i;         // template parameters T and i
   ::T t2 = ::i;     // global namespace members T and i
 }
 ```
+Here, the template `f` has a type template parameter called `T`, rather
+than an unnamed constant template parameter of class `T`.
 — *end example*]
+The *parameter-declaration* of a *template-parameter* shall not have a
+*storage-class-specifier*. Types shall not be defined in a template
+parameter declaration.
+The *identifier* in a *template-parameter* denoting a type or template
+is not looked up. An *identifier* that does not follow an ellipsis is
+defined to be
+- a *typedef-name* for a *type-parameter*,
+- a *template-name* for a *variable-tt-parameter*,
+- a *template-name* for a *type-tt-parameter*, or
+- a *concept-name* for a *concept-tt-parameter*,
+in the scope of the template declaration.
 A *type-constraint* `Q` that designates a concept `C` can be used to
 constrain a contextually-determined type or template type parameter pack
 `T` with a *constraint-expression* `E` defined as follows. If `Q` is of
+the form `C<A₁, …, Aₙ>`, then let `E'` be `C<T, A₁, …, Aₙ>`. Otherwise,
 let `E'` be `C<T>`. If `T` is not a pack, then `E` is `E'`, otherwise
 `E` is `(E' && ...)`. This *constraint-expression* `E` is called the
 *immediately-declared constraint* of `Q` for `T`. The concept designated
 by a *type-constraint* shall be a type concept [[temp.concept]].
 A *type-parameter* that starts with a *type-constraint* introduces the
 immediately-declared constraint of the *type-constraint* for the
 parameter.
+[*Example 3*:
 ``` cpp
 template<typename T> concept C1 = true;
 template<typename... Ts> concept C2 = true;
 template<typename T, typename U> concept C3 = true;
 template<C3<int>... T> struct s5;       // associates (C3<T, int> && ...)
 ```
 — *end example*]
+A constant template parameter shall have one of the following (possibly
+cv-qualified) types:
 - a structural type (see below),
 - a type that contains a placeholder type [[dcl.spec.auto]], or
 - a placeholder for a deduced class type [[dcl.type.class.deduct]].
 - a scalar type, or
 - 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 base classes and non-static data members are
+    structural types or (possibly multidimensional) arrays thereof.
+An *id-expression* naming a constant template parameter of class type
 `T` denotes a static storage duration object of type `const T`, known as
+a *template parameter object*, which is template-argument-equivalent
+[[temp.type]] to the corresponding template argument after it has been
+converted to the type of the template parameter [[temp.arg.nontype]]. No
+two template parameter objects are template-argument-equivalent.
+[*Note 2*: If an *id-expression* names a non-reference constant
+template parameter, then it is a prvalue if it has non-class type.
 Otherwise, if it is of class type `T`, it is an lvalue and has type
 `const T` [[expr.prim.id.unqual]]. — *end note*]
+[*Example 4*:
 ``` cpp
 using X = int;
 struct A {};
 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: 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*]
+[*Note 3*:
+A constant template parameter cannot be declared to have type cv `void`.
+[*Example 5*:
 ``` cpp
 template<void v> class X;       // error
 template<void* pv> class Y;     // OK
 ```
 — *end example*]
 — *end note*]
+A constant template parameter of type “array of `T`” or of function type
+`T` is adjusted to be of type “pointer to `T`”.
+[*Example 6*:
 ``` cpp
 template<int* a>   struct R { ... };
 template<int b[5]> struct S { ... };
 int p;
 S<v> z;                         // OK due to both adjustment and conversion
 ```
 — *end example*]
+A constant template parameter declared with a type that contains a
 placeholder type with a *type-constraint* introduces the
 immediately-declared constraint of the *type-constraint* for the
 invented type corresponding to the placeholder [[dcl.fct]].
+A *default template argument* is a template argument [[temp.arg]]
+specified after `=` in a *template-parameter*. A default template
+argument may be specified for any kind of template parameter that is not
+a template 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 arguments 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]].
+[*Example 7*:
 ``` cpp
 template<class T1, class T2 = int> class A;
 template<class T1 = int, class T2> class A;
 ```
 ```
 — *end example*]
 If a *template-parameter* of a class template, variable template, or
+alias template has a default template argument, each subsequent
+*template-parameter* shall either have a default template argument
+supplied or declare a template parameter pack. If a *template-parameter*
+of a primary class template, primary variable template, or alias
+template declares a template parameter pack, it shall be the last
+*template-parameter*. If a *template-parameter* of a function template
+declares a template parameter pack, it shall not be followed by another
+*template-parameter* unless that template parameter is deducible from
+the parameter-type-list [[dcl.fct]] of the function template or has a
+default argument [[temp.deduct]]. A template parameter of a deduction
 guide template [[temp.deduct.guide]] that does not have a default
 argument shall be deducible from the parameter-type-list of the
 deduction guide template.
+[*Example 8*:
 ``` cpp
 template<class T1 = int, class T2> class B;     // error
 // U can be neither deduced from the parameter-type-list nor specified
 template<class... T, class U> void g() { }      // error
 ```
 — *end example*]
+When parsing a default template argument for a constant 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 { ... };
 ```
 — *end example*]
 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();
 }
 ```
 — *end example*]
+The associated constraints of a template template parameter shall not
+contain a concept-dependent constraint [[temp.constr.concept]].
+[*Example 11*:
 ``` cpp
+template<
+  template<typename> concept C,
+  template<C> class TT  // error: C forms a concept-dependent constraint
+>
+struct A {};
 ```
 — *end example*]
 ## Names of template specializations <a id="temp.names">[[temp.names]]</a>
 ``` bnf
 template-argument:
   constant-expression
   type-id
+ nested-name-specifierₒₚₜ template-name
+  nested-name-specifier 'template' template-name
+  braced-init-list
 ```
 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
+either
+- it follows a *splice-specifier* that either
+  - appears in a type-only context or
+  - is preceded by `template` or `typename`, or
+- 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*]
 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
+  static constexpr std::meta::info r = ^^T::adjust;
+  T* p3 = [:r:]<200>();                 // error: < means less than
+  T* p4 = template [:r:]<200>();        // OK, < starts template argument list
+}}
 ```
 — *end example*]
+When parsing a *template-argument-list*, the first non-nested `>`[^1]
 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* or
+*splice-specialization-specifier*.
 [*Note 2*: The second `>` token produced by this replacement rule can
+terminate an enclosing *template-id* or
+*splice-specialization-specifier* construct or it can be part of a
 different construct (e.g., a cast). — *end note*]
 [*Example 2*:
 ``` cpp
 — *end example*]
 The keyword `template` shall not appear immediately after a declarative
 *nested-name-specifier* [[expr.prim.id.qual]].
+The *constant-expression* of a *template-argument* shall not be an
+unparenthesized *splice-expression*.
+[*Example 3*:
+``` cpp
+template<int> struct S { };
+constexpr int k = 5;
+constexpr std::meta::info r = ^^k;
+S<[:r:]> s1;                        // error: unparenthesized splice-expression used as template argument
+S<([:r:])> s2;                      // OK
+S<[:r:] + 1> s3;                    // OK
+```
+— *end example*]
 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 well-formed even when lookup for the name would already find a
 template. — *end note*]
+[*Example 4*:
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class U> void f(U);
 D<B<int> > db;
 ```
 — *end example*]
+A *template-id* or *splice-specialization-specifier* is *valid* if
 - there are at most as many arguments as there are parameters or a
   parameter is a template parameter pack [[temp.variadic]],
 - there is an argument for each non-deducible non-pack parameter that
   does not have a default *template-argument*,
+- each *template-argument* matches the corresponding template parameter
+  [[temp.arg]],
 - substitution of each template argument into the following template
   parameters (if any) succeeds, and
+- if the *template-id* or *splice-specialization-specifier* is
+ non-dependent, the associated constraints are satisfied as specified
+  in the next paragraph.
+A *simple-template-id* or *splice-specialization-specifier* shall be
+valid unless its respective *template-name* or *splice-specifier* names
+or designates a function template [[temp.deduct]].
+[*Example 5*:
 ``` cpp
 template<class T, T::type n = 0> class X;
 struct S {
   using type = int;
 using T5 = X<S>;                // OK
 ```
 — *end example*]
+When the *template-name* of a *simple-template-id* or the
+*splice-specifier* of a *splice-specialization-specifier* designates a
+constrained non-function template or a constrained template template
+parameter, and all *template-argument*s in the *simple-template-id* or
+*splice-specialization-specifier* are non-dependent [[temp.dep.temp]],
+the associated constraints [[temp.constr.decl]] of the constrained
+template shall be satisfied [[temp.constr.constr]].
+[*Example 6*:
 ``` cpp
 template<typename T> concept C1 = sizeof(T) != sizeof(int);
 template<C1 T> struct S1 { };
 [*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 7*:
 ``` cpp
 template<typename T> concept C = true;
 static_assert(C<int>);      // OK
 ```
 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
 ### General <a id="temp.arg.general">[[temp.arg.general]]</a>
+The type and form of each *template-argument* specified in a
+*template-id* or in a *splice-specialization-specifier* shall match the
+type and form specified for the corresponding parameter declared by the
+template in its *template-parameter-list*. When the parameter declared
+by the template is a template parameter pack [[temp.variadic]], it will
+correspond to zero or more *template-argument*s.
 [*Example 1*:
 ``` cpp
 template<class T> class Array {
 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*.[^2]
 [*Example 2*:
 ``` cpp
 template<class T> void f();
 ```
 — *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 where the template parameter is
+used. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
 X<Y::S> y;          // error: S not accessible
 ```
 — *end example*]
+For a template argument that is a class type or a class template, the
 template definition has no special access rights to the members of the
+template argument.
 [*Example 4*:
 ``` cpp
 template <template <class TT> class T> class A {
 A<B> b;             // error: A has no access to B::S
 ```
 — *end example*]
+When template argument packs or default template arguments are used, a
 *template-argument* list can be empty. In that case the empty `<>`
 brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
 }
 ```
 — *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* or *splice-specialization-specifier* does
+not designate a function, a default *template-argument* is implicitly
+instantiated [[temp.inst]] when the value of that default argument is
+needed.
 [*Example 7*:
 ``` cpp
 template<typename T, typename U = int> struct S { };
 — *end example*]
 A *template-argument* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
+### Type template arguments <a id="temp.arg.type">[[temp.arg.type]]</a>
+A *template-argument* for a type template parameter shall be a
+*type-id*.
 [*Example 1*:
 ``` cpp
 template <class T> class X { };
 — *end example*]
 [*Note 1*: A template type argument can be an incomplete type
 [[term.incomplete.type]]. — *end note*]
+### Constant template arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
+A template argument E for a constant template parameter with declared
+type `T` shall be such that the invented declaration
 ``` cpp
+T x = E ;
 ```
+satisfies the semantic constraints for the definition of a `constexpr`
+variable with static storage duration [[dcl.constexpr]]. If `T` contains
+a placeholder type [[dcl.spec.auto]] or a placeholder for a deduced
+class type [[dcl.type.class.deduct]], the type of the parameter is
+deduced from the above declaration.
+[*Note 1*: E is a *template-argument* or (for a default template
+argument) an *initializer-clause*. — *end note*]
+If the parameter type thus deduced is not permitted for a constant
+template parameter [[temp.param]], the program is ill-formed.
+The value of a constant template parameter P of (possibly deduced) type
+`T` is determined from its template argument A as follows. If `T` is not
+a class type and A is not a *braced-init-list*, A shall be a converted
+constant expression [[expr.const]] of type `T`; the value of P is A (as
+converted).
+Otherwise, a temporary variable
+``` cpp
+constexpr T v = A;
+```
+is introduced. The lifetime of `v` ends immediately after initializing
+it and any template parameter object (see below). For each such
+variable, the *id-expression* `v` is termed a *candidate initializer*.
+If `T` is a class type, a template parameter object [[temp.param]]
+exists that is constructed so as to be template-argument-equivalent to
+`v`; P denotes that template parameter object. P is copy-initialized
+from an unspecified candidate initializer that is
+template-argument-equivalent to `v`. If, for the initialization from any
+candidate initializer,
+- the initialization would be ill-formed, or
+- the full-expression of an invented *init-declarator* for the
+  initialization would not be a constant expression when interpreted as
+  a *constant-expression* [[expr.const]], or
+- the initialization would cause P to not be
+  template-argument-equivalent [[temp.type]] to `v`,
+the program is ill-formed.
+Otherwise, the value of P is that of v.
+For a constant template parameter of reference or pointer type, or for
+each non-static data member of reference or pointer type in a constant
+template parameter of class type or subobject thereof, the reference or
+pointer value shall not refer or point to (respectively):
 - a temporary object [[class.temporary]],
 - a string literal object [[lex.string]],
 - the result of a `typeid` expression [[expr.typeid]],
 - a predefined `__func__` variable [[dcl.fct.def.general]], or
 - a subobject [[intro.object]] of one of the above.
 [*Example 1*:
+``` cpp
+template <int& r> class A{};
+extern int x;
+A<x> a;                 // OK
+void f(int p) {
+  constexpr int& r = p; // OK
+  A<r> a;               // error: a static constexpr int& variable cannot be initialized to refer to p here
+}
+```
+— *end example*]
+[*Example 2*:
 ``` cpp
 template<const int* pci> struct X { ... };
 int ai[10];
 X<ai> xi;                       // array to pointer and qualification conversions
 template<auto n> struct B { ... };
 B<5> b1;                        // OK, template parameter type is int
 B<'a'> b2;                      // OK, template parameter type is char
 B<2.5> b3;                      // OK, template parameter type is double
 B<void(0)> b4;                  // error: template parameter type cannot be void
+template<int i> struct C { /* ... */ };
+C<{ 42 }> c1;   // OK
+struct J1 {
+  J1 *self = this;
+};
+B<J1{}> j1;     // error: initialization of template parameter object is not a constant expression
+struct J2 {
+  J2 *self = this;
+  constexpr J2() {}
+  constexpr J2(const J2&) {}
+};
+B<J2{}> j2;     // error: template parameter object not template-argument-equivalent to introduced temporary
 ```
 — *end example*]
 [*Note 2*:
 A *string-literal* [[lex.string]] is not an acceptable
+*template-argument* for a constant template parameter of non-class type.
+[*Example 3*:
 ``` cpp
 template<class T, T p> class X {
   ...
 };
 — *end note*]
 [*Note 3*:
 A temporary object is not an acceptable *template-argument* when the
+corresponding template parameter has reference type.
+[*Example 4*:
 ``` cpp
 template<const int& CRI> struct B { ... };
 B<1> b1;                        // error: temporary would be required for template argument
 — *end note*]
 ### 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 template. For a *type-tt-parameter*, the name shall denote a
+class template or alias template. For a *variable-tt-parameter*, the
+name shall denote a variable template. For a *concept-tt-parameter*, the
+name shall denote a concept. 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*:
                     // V<int*> within C<A> uses the partial specialization, so c.z.x has type long
 ```
 — *end example*]
+A template template parameter `P` and a *template-argument* `A` are
+*compatible* if
+- `A` denotes a class template or an alias template and `P` is a type
+  template template parameter,
+- `A` denotes a variable template and `P` is a variable template
+ template parameter, or
+- `A` denotes a concept and `P` is a concept template parameter.
+A template *template-argument* `A` matches a template template parameter
+`P` when `A` and `P` are compatible and `P` is at least as specialized
+as `A`, ignoring constraints on `A` if `P` is unconstrained. If `P`
+contains a template parameter pack, then `A` also matches `P` if each of
+`A`’s template parameters matches the corresponding template parameter
+declared in the *template-head* of `P`. Two template parameters match if
+they are of the same kind, for constant template parameters, their types
+are equivalent [[temp.over.link]], and for template template parameters,
+each of their corresponding template parameters matches, recursively.
+When `P`’s *template-head* contains a *template-parameter* that declares
+a template parameter pack [[temp.variadic]], the template parameter pack
+will match zero or more template parameters or template parameter packs
+declared in the *template-head* of `A` with the same type and form as
+the template parameter pack declared in `P` (ignoring whether those
+template parameters are template parameter packs).
 [*Example 2*:
 ``` cpp
 template<class T> class A { ... };
 S<Z> s3;            // OK, P is at least as specialized as Z
 ```
 — *end example*]
+A template template parameter `P` is at least as specialized as a
 template *template-argument* `A` if, given the following rewrite to two
 function templates, the function template corresponding to `P` is at
 least as specialized as the function template corresponding to `A`
 according to the partial ordering rules for function templates
 [[temp.func.order]]. Given an invented class template `X` with the
 - Each of the two function templates has the same template parameters
   and *requires-clause* (if any), respectively, as `P` or `A`.
 - Each function template has a single function parameter whose type is a
   specialization of `X` with template arguments corresponding to the
   template parameters from the respective function template where, for
+  each *template-parameter* `PP` in the *template-head* of the function
+  template, a corresponding *template-argument* `AA` is formed. If `PP`
   declares a template parameter pack, then `AA` is the pack expansion
+  `PP...` [[temp.variadic]]; otherwise, `AA` is an *id-expression*
+ denoting `PP`.
 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.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 five different kinds of
 constraints:
 - conjunctions [[temp.constr.op]],
+- disjunctions [[temp.constr.op]],
+- atomic constraints [[temp.constr.atomic]],
+- concept-dependent constraints [[temp.constr.concept]], and
+- fold expanded constraints [[temp.constr.fold]].
 In order for a constrained template to be instantiated [[temp.spec]],
 its associated constraints [[temp.constr.decl]] shall be satisfied as
 described in the following subclauses.
 — *end note*]
 To determine if an atomic constraint is *satisfied*, the parameter
 mapping and template arguments are first substituted into its
+expression. If substitution results in an invalid type or expression in
+the immediate context of the atomic constraint [[temp.deduct.general]],
 the constraint is not satisfied. Otherwise, the lvalue-to-rvalue
 conversion [[conv.lval]] is performed if necessary, and `E` shall be a
 constant expression of type `bool`. The constraint is satisfied if and
 only if evaluation of `E` results in `true`. If, at different points in
 the program, the satisfaction result is different for identical atomic
                                 // call is ill-formed even though #2 is a better match
 ```
 — *end example*]
+#### Concept-dependent constraints <a id="temp.constr.concept">[[temp.constr.concept]]</a>
+A *concept-dependent constraint* `CD` is an atomic constraint whose
+expression is a concept-id `CI` whose *concept-name* names a dependent
+concept named `C`.
+To determine if `CD` is *satisfied*, the parameter mapping and template
+arguments are first substituted into `C`. If substitution results in an
+invalid concept-id in the immediate context of the constraint
+[[temp.deduct.general]], the constraint is not satisfied. Otherwise, let
+`CI'` be the normal form [[temp.constr.normal]] of the concept-id after
+substitution of `C`.
+[*Note 1*: Normalization of `CI` might be ill-formed; no diagnostic is
+required. — *end note*]
+To form `CI''`, each appearance of `C`'s template parameters in the
+parameter mappings of the atomic constraints (including
+concept-dependent constraints) in `CI'` is substituted with their
+respective arguments from the parameter mapping of `CD` and the
+arguments of `CI`.
+`CD` is satisfied if `CI''` is satisfied.
+[*Note 2*: Checking whether `CI''` is satisfied can lead to further
+normalization of concept-dependent constraints. — *end note*]
+[*Example 1*:
+``` cpp
+template<typename>
+concept C = true;
+template<typename T, template<typename> concept CC>
+concept D = CC<T>;
+template<typename U,
+         template<typename> concept CT,
+         template<typename, template<typename> concept> concept CU>
+int f() requires CU<U, CT>;
+int i = f<int, C, D>();
+```
+In this example, the associated constraints of `f` consist of a
+concept-dependent constraint whose expression is the concept-id
+`CU<U, CT>` with the mapping `U` ↦ `U`, `CT` ↦ `CT`, `CU` ↦ `CU`. The
+result of substituting `D` into this expression is `D<U, CT>`. We
+consider the normal form of the resulting concept-id, which is `CC<T>`
+with the mapping `T` ↦ `U`, `CC` ↦ `CT`. By recursion, `C` is
+substituted into `CC<T>`, and the result is normalized to the atomic
+constraint `true`, which is satisfied.
+— *end example*]
+#### Fold expanded constraint <a id="temp.constr.fold">[[temp.constr.fold]]</a>
+A *fold expanded constraint* is formed from a constraint C and a
+*fold-operator* which can either be `&&` or `||`. A fold expanded
+constraint is a pack expansion [[temp.variadic]]. Let N be the number of
+elements in the pack expansion parameters [[temp.variadic]].
+A fold expanded constraint whose *fold-operator* is `&&` is satisfied if
+it is a valid pack expansion and if N = 0 or if for each i where
+0 ≤ i < N in increasing order, C is satisfied when replacing each pack
+expansion parameter with the corresponding iᵗʰ element. No substitution
+takes place for any i greater than the smallest i for which the
+constraint is not satisfied.
+A fold expanded constraint whose *fold-operator* is `||` is satisfied if
+it is a valid pack expansion, N > 0, and if for i where 0 ≤ i < N in
+increasing order, there is a smallest i for which C is satisfied when
+replacing each pack expansion parameter with the corresponding iᵗʰ
+element. No substitution takes place for any i greater than the smallest
+i for which the constraint is satisfied.
+[*Note 1*: If the pack expansion expands packs of different size, then
+it is invalid and the fold expanded constraint is not
+satisfied. — *end note*]
+Two fold expanded constraints are *compatible for subsumption* if their
+respective constraints both contain an equivalent unexpanded pack
+[[temp.over.link]].
 ### Constrained declarations <a id="temp.constr.decl">[[temp.constr.decl]]</a>
 A template declaration [[temp.pre]] or templated function declaration
 [[dcl.fct]] can be constrained by the use of a *requires-clause*. This
 allows the specification of constraints for that declaration as an
 - The normal form of an expression `( E )` is the normal form of `E`.
 - The normal form of an expression `E1 || E2` is the disjunction
   [[temp.constr.op]] of the normal forms of `E1` and `E2`.
 - The normal form of an expression `E1 && E2` is the conjunction of the
   normal forms of `E1` and `E2`.
+- For a concept-id `C<A₁, A₂, …, Aₙ>` termed `CI`:
+ - If `C` names a dependent concept, the normal form of `CI` is a
+    concept-dependent constraint whose concept-id is `CI` and whose
+ parameter mapping is the identity mapping.
+ - Otherwise, to form `CE`, any non-dependent concept template argument
+    `Aᵢ` is substituted into the *constraint-expression* of `C`. If any
+    such substitution results in an invalid concept-id, the program is
+    ill-formed; no diagnostic is required. The normal form of `CI` is
+    the result of substituting, in the normal form `N` of `CE`,
+    appearances of `C`'s template parameters in the parameter mappings
+    of the atomic constraints in `N` with their respective arguments
+    from `C`. If any such substitution results in an invalid type or
+    expression, the program is ill-formed; no diagnostic is required.
   \[*Example 1*:
   ``` cpp
   template<typename T> concept A = T::value || true;
   template<typename U> concept B = A<U*>;
   template<typename V> concept C = B<V&>;
   mapping), despite the expression `T::value` being ill-formed for a
   pointer type `T`. Normalization of `C`'s *constraint-expression*
   results in the program being ill-formed, because it would form the
   invalid type `V&*` in the parameter mapping.
   — *end example*]
+- For a *fold-operator* `Op` [[expr.prim.fold]] that is either `&&` or
+  `||`:
+  - The normal form of an expression `( ... Op E )` is the normal form
+    of `( E Op ... )`.
+  - The normal form of an expression `( E1 Op ... Op E2 )` is the normal
+    form of
+    - `( E1 Op ... ) Op E2` if `E1` contains an unexpanded pack, or
+    - `E1 Op ( E2 Op ... )` otherwise.
+  - The normal form of an expression `F` of the form `( E Op ... )` is
+    as follows:
+    If `E` contains an unexpanded concept template parameter pack, it
+    shall not contain an unexpanded template parameter pack of another
+    kind. Let `E'` be the normal form of `E`.
+    - If `E` contains an unexpanded concept template parameter pack `Pₖ`
+      that has corresponding template arguments in the parameter mapping
+      of any atomic constraint (including concept-dependent constraints)
+      of `E'`, the number of arguments specified for all such `Pₖ` shall
+      be the same number N. The normal form of `F` is the normal form of
+      `E₀ Op … Op E_{N-1}` after substituting in `Eᵢ` the respective iᵗʰ
+      concept argument of each `Pₖ`. If any such substitution results in
+      an invalid type or expression, the program is ill-formed; no
+      diagnostic is required.
+    - Otherwise, the normal form of `F` is a fold expanded constraint
+      [[temp.constr.fold]] whose constraint is `E'` and whose
+      *fold-operator* is `Op`.
 - The normal form of any other expression `E` is the atomic constraint
   whose expression is `E` and whose parameter mapping is the identity
   mapping.
 The process of obtaining the normal form of a *constraint-expression* is
 The associated constraints of \#3 are `requires (T x) { ++x; }` (with
 mapping `T` ↦ `U`).
 — *end example*]
+[*Example 3*:
+``` cpp
+template<typename T>
+concept C = true;
+template<typename T, template<typename> concept CT>
+concept CC = CT<T>;
+template<typename U,
+         template<typename, template<typename> concept> concept CT>
+  void f() requires CT<U*, C>;
+template<typename U>
+  void g() requires CC<U*, C>;
+```
+The normal form of the associated constraints of `f` is the
+concept-dependent constraint `CT<T, C>`.
+The normal form of the associated constraints of `g` is the atomic
+constraint `true`.
+— *end example*]
+[*Example 4*:
+``` cpp
+template<typename T>
+concept A = true;
+template<typename T>
+concept B = A<T> && true;                               // B subsumes A
+template<typename T>
+concept C = true;
+template<typename T>
+concept D = C<T> && true;                               // D subsumes C
+template<typename T, template<typename> concept... CTs>
+concept all_of = (CTs<T> && ...);
+template<typename T> requires all_of<T, A, C>
+  constexpr int f(T) { return 1; }                      // #1
+template<typename T> requires all_of<T, B, D>
+  constexpr int f(T) { return 2; }                      // #2
+static_assert(f(1) == 2);                               // ok
+```
+The normal form of `all_of<T, A, C>` is the conjunction of the normal
+forms of `A<T>` and `C<T>`.
+Similarly, the normal form of `all_of<T, B, D>` is the conjunction of
+the normal forms of `B<T>` and `D<T>`.
+\#2 therefore is more constrained than \#1.
+— *end example*]
+[*Example 5*:
+``` cpp
+template<typename T, template<typename> concept>
+struct wrapper {};
+template<typename... T, template<typename> concept... CTs>
+  int f(wrapper<T, CTs>...) requires (CTs<T> && ...);   // error: fold expression contains
+                                                        // different kinds of template parameters
+```
+— *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[^3]
 of P, Pᵢ subsumes every conjunctive clause Qⱼ in the conjunctive normal
+form[^4]
 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}$,
 - an atomic constraint A subsumes another atomic constraint B if and
   only if A and B are identical using the rules described in
+  [[temp.constr.atomic]], and
+- a fold expanded constraint A subsumes another fold expanded constraint
+  B if they are compatible for subsumption, have the same
+  *fold-operator*, and the constraint of A subsumes that of B.
 [*Example 1*: Let A and B be atomic constraints [[temp.constr.atomic]].
 The constraint A ∧ B subsumes A, but A does not subsume A ∧ B. The
 constraint A subsumes A ∨ B, but A ∨ B does not subsume A. Also note
 that every constraint subsumes itself. — *end example*]
   [[temp.spec.partial.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
+The associated constraints `C` of a declaration `D` are *eligible for
+subsumption* unless `C` contains a concept-dependent constraint.
 A declaration `D1` is *at least as constrained* as a declaration `D2` if
 - `D1` and `D2` are both constrained declarations and `D1`’s associated
+  constraints are eligible for subsumption and subsume those of `D2`; or
 - `D2` has no associated constraints.
 A declaration `D1` is *more constrained* than another declaration `D2`
 when `D1` is at least as constrained as `D2`, and `D2` is not at least
 as constrained as `D1`.
 g(0);                           // selects #4
 ```
 — *end example*]
+[*Example 3*:
+``` cpp
+template<template<typename T> concept CT, typename T>
+struct S {};
+template<typename T>
+concept A = true;
+template<template<typename T> concept X, typename T>
+int f(S<X, T>) requires A<T> { return 42; }             // #1
+template<template<typename T> concept X, typename T>
+int f(S<X, T>) requires X<T> { return 43; }             // #2
+f(S<A, int>{});                 // ok, select #1 because #2 is not eligible for subsumption
+```
+— *end example*]
+A non-template function `F1` is *more partial-ordering-constrained* than
+a non-template function `F2` if
+- they have the same non-object-parameter-type-lists [[dcl.fct]], and
+- if they are member functions, both are direct members of the same
+  class, and
+- if both are non-static member functions, they have the same types for
+  their object parameters, and
+- the declaration of `F1` is more constrained than the declaration of
+  `F2`.
 ## Type equivalence <a id="temp.type">[[temp.type]]</a>
 Two *template-id*s are the same if
 - their *template-name*s, *operator-function-id*s, or
   *literal-operator-id*s refer to the same template, and
 - their corresponding type *template-argument*s are the same type, and
+- the template parameter values determined by their corresponding
+ constant template arguments [[temp.arg.nontype]] are
+  template-argument-equivalent (see below), and
 - their corresponding template *template-argument*s refer to the same
   template.
 Two *template-id*s that are the same refer to the same class, function,
 or variable.
 type and
 - they are of integral type and their values are the same, or
 - they are of floating-point type and their values are identical, or
 - they are of type `std::nullptr_t`, or
+- they are of type `std::meta::info` and their values compare equal
+  [[expr.eq]], or
+- they are of enumeration type and their values are the same,[^5] or
 - they are of pointer type and they have the same pointer value, or
 - they are of pointer-to-member type and they refer to the same class
   member or are both the null member pointer value, or
 - they are of reference type and they refer to the same object or
   function, or
 - they are of array type and their corresponding elements are
+  template-argument-equivalent,[^6] or
 - they are of union type and either they both have no active member or
   they have the same active member and their active members are
   template-argument-equivalent, or
+- they are of a closure type [[expr.prim.lambda.closure]], or
 - they are of class type and their corresponding direct subobjects and
   reference members are template-argument-equivalent.
 [*Example 1*:
 [[temp.over.link]].
 [*Note 1*: However, such a type might be aliased, e.g., by a
 *typedef-name*. — *end note*]
+For a type template parameter pack `T`, `T...[`*constant-expression*`]`
+denotes a unique dependent type.
+If the *constant-expression* of a *pack-index-specifier* is
+value-dependent, two such *pack-index-specifier*s refer to the same type
+only if their *constant-expression*s are equivalent [[temp.over.link]].
+Otherwise, two such *pack-index-specifier*s refer to the same type only
+if their indexes have the same value.
 ## 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
 *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. For the purpose of name lookup and
+instantiation, the *compound-statement* of an *expansion-statement* is
+considered a template definition.
 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>
 — *end example*]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
+Deduction guides are used when a *template-name* or
+*splice-type-specifier* 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 requires-clauseₒₚₜ ';'
 ```
 [*Example 1*:
 ``` cpp
 ```
 — *end example*]
 The same restrictions apply to the *parameter-declaration-clause* of a
+deduction guide as in a function declaration [[dcl.fct]], except that a
+generic parameter type placeholder [[dcl.spec.auto]] shall not appear in
+the *parameter-declaration-clause* of a deduction guide. 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
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
 — *end example*]
 — *end example*]
 [*Note 1*:
+A specialization of a conversion function template is named 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*]
+An expression designating a particular specialization of a conversion
+function template can only be formed with a *splice-expression*. There
+is no analogous syntax to form a *template-id* [[temp.names]] for such a
+function by providing an explicit template argument list
+[[temp.arg.explicit]].
 — *end note*]
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 foo(1);                         // xs contains one init-capture
 ```
 — *end example*]
+A *structured binding pack* is an *sb-identifier* that introduces zero
+or more structured bindings [[dcl.struct.bind]].
+[*Example 4*:
+``` cpp
+auto foo() -> int(&)[2];
+template <class T>
+void g() {
+  auto [...a] = foo();          // a is a structured binding pack containing two elements
+  auto [b, c, ...d] = foo();    // d is a structured binding pack containing zero elements
+}
+```
+— *end example*]
+A *pack* is a template parameter pack, a function parameter pack, an
+*init-capture* pack, or a structured binding pack. The number of
+elements of a template parameter pack or a function parameter pack is
+the number of arguments provided for the parameter pack. The number of
+elements of an *init-capture* pack is the number of elements in the pack
+expansion of its *initializer*.
 A *pack expansion* consists of a *pattern* and an ellipsis, the
 instantiation of which produces zero or more instantiations of the
 pattern in a list (described below). The form of the pattern depends on
 the context in which the expansion occurs. Pack expansions can occur in
 - In a function parameter pack [[dcl.fct]]; the pattern is the
   *parameter-declaration* without the ellipsis.
 - In a *using-declaration* [[namespace.udecl]]; the pattern is a
   *using-declarator*.
+- In a *friend-type-declaration* [[class.mem.general]]; the pattern is a
+  *friend-type-specifier*.
 - In a template parameter pack that is a pack expansion [[temp.param]]:
   - if the template parameter pack is a *parameter-declaration*; the
     pattern is the *parameter-declaration* without the ellipsis;
   - if the template parameter pack is a *type-parameter*; the pattern is
+    the corresponding *type-parameter* without the ellipsis;
+  - if the template parameter pack is a template template parameter; the
+    pattern is the corresponding *type-tt-parameter*,
+    *variable-tt-parameter*, or *concept-tt-parameter* without the
+    ellipsis.
 - In an *initializer-list* [[dcl.init]]; the pattern is an
   *initializer-clause*.
 - In a *base-specifier-list* [[class.derived]]; the pattern is a
   *base-specifier*.
 - In a *mem-initializer-list* [[class.base.init]] for a
   pattern is the *mem-initializer*.
 - In a *template-argument-list* [[temp.arg]]; the pattern is a
   *template-argument*.
 - In an *attribute-list* [[dcl.attr.grammar]]; the pattern is an
   *attribute*.
+- In an *annotation-list* [[dcl.attr.grammar]]; the pattern is an
+  *annotation*.
 - In an *alignment-specifier* [[dcl.align]]; the pattern is the
   *alignment-specifier* without the ellipsis.
 - In a *capture-list* [[expr.prim.lambda.capture]]; the pattern is the
   *capture* without the ellipsis.
 - In a `sizeof...` expression [[expr.sizeof]]; the pattern is an
   *identifier*.
+- In a *pack-index-expression*; the pattern is an *identifier*.
+- In a *pack-index-specifier*; the pattern is a *typedef-name*.
 - In a *fold-expression* [[expr.prim.fold]]; the pattern is the
   *cast-expression* that contains an unexpanded pack.
+- In a fold expanded constraint [[temp.constr.fold]]; the pattern is the
+  constraint of that fold expanded constraint.
+[*Example 5*:
 ``` cpp
 template<class ... Types> void f(Types ... rest);
 template<class ... Types> void g(Types ... rest) {
   f(&rest ...);     // ``&rest ...'' is a pack expansion; ``&rest'' is its pattern
 nested pack expansion; such packs are called *unexpanded packs* in the
 pattern. All of the packs expanded by a pack expansion shall have the
 same number of arguments specified. An appearance of a name of a pack
 that is not expanded is ill-formed.
+[*Example 6*:
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
 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 *typedef-name* for a type template parameter pack,
+ - an *id-expression* for a constant template parameter pack, or
+ - a *template-name* for a template template parameter pack
+ designating the iᵗʰ corresponding type, constant, or template 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;
 - 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; otherwise
+- if the pack is a structured binding pack, the element is an
+  *id-expression* designating the $i^\textrm{th}$ structured binding in
+  the pack that resulted from the structured binding 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.
+When instantiating a *pack-index-expression* P, let K be the index of P.
+The instantiation of P is the *id-expression* `E_K`.
+When instantiating a *pack-index-specifier* P, let K be the index of P.
+The instantiation of P is the *typedef-name* `E_K`.
+The instantiation of an *alignment-specifier* with an ellipsis produces
+`E₁` `E₂` … `E_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$`))`
 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 7*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
+A fold expanded constraint is not instantiated [[temp.constr.fold]].
 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 8*:
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
                     // which refers to the primary template
 ```
 — *end example*]
+A constant template argument is non-specialized if it is the name of a
+constant template parameter. All other constant template 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
+ constant template 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
   — *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.[^7]
 - 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
 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.[^8]
 #### 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.
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
+[*Note 2*: Most expressions that use template parameters use constant
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 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 a first declaration of the function template
+[[temp.res.general]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
+- if they declare constant template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
+- if they declare template template parameters, their *template-head*s
+  are equivalent.
 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.
 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 declarations A and B of function templates
+- introduce the same name,
 - have corresponding signatures [[basic.scope.scope]],
+- would declare the same entity, when considering A and B to correspond
+ in that determination [[basic.link]], and
 - accept and are satisfied by the same set of template argument lists,
+but do not correspond, 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
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
+To produce the transformed template, for each type, constant, type
+template, variable template, or concept template parameter (including
+template parameter packs [[temp.variadic]] thereof) synthesize a unique
+type, value, class template, variable template, or concept,
+respectively, and substitute it for each occurrence of that parameter in
+the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
+synthesized for a constant template parameter is also a unique
 synthesized type. — *end note*]
+A synthesized template has the same *template-head* as its corresponding
+template template parameter.
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order
 A *template-declaration* in which the *declaration* is an
 *alias-declaration* [[dcl.pre]] declares the *identifier* to be an
 *alias template*. An alias template is a name for a family of types. The
 name of the alias template is a *template-name*.
+A
+- *template-id* that is not the operand of a *reflect-expression* or
+-
+that designates the specialization of an alias template is equivalent to
+the associated type obtained by substitution of its *template-argument*s
+for the *template-parameter*s in the *defining-type-id* of the alias
+template. Any other *template-id* that names a specialization of an
+alias template is a *typedef-name* for a type alias.
 [*Note 1*: An alias template name is never deduced. — *end note*]
 [*Example 1*:
 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>
 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
 }
 ```
 — *end example*]
+A *type-only context* is defined as follows: A qualified or unqualified
+name is said to be in a type-only context if it is the terminal name of
+- a *typename-specifier*, *type-requirement*, *nested-name-specifier*,
+  *elaborated-type-specifier*, *class-or-decltype*,
+  *using-enum-declarator*, or
+- a *simple-type-specifier* of a *friend-type-specifier*, 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 *function-definition* in namespace scope,
   - *member-declaration*,
+  - *parameter-declaration* in a *member-declaration*,[^9] 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 *template-parameter* (which necessarily
+    declares a constant template parameter).
+A *splice-specifier* or *splice-specialization-specifier*
+[[basic.splice]] is said to be in a type-only context if a hypothetical
+qualified name appearing in the same position would be in a type-only
+context.
 [*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
+enum class Enum { A, B, C };
 template<class T> struct S {
   using Ptr = PtrTraits<T>::Ptr;        // OK, in a defining-type-id
+  using Alias = [:^^int:];              // OK, in a defining-type-id
   T::R f(T::P p) {                      // OK, class scope
     return static_cast<T::R>(p);        // OK, type-id of a static_cast
   }
   auto g() -> S<T*>::Ptr;               // OK, trailing-return-type
+  auto h() -> [:^^S:]<T*>;              // OK, trailing-return-type
+  using enum [:^^Enum:];                // OK, using-enum-declarator
 };
 template<typename T> void f() {
   void (*pf)(T::X);                     // variable pf of type void* initialized with T::X
   void g(T::X);                         // error: T::X at block scope does not denote a type
                                         // (attempt to declare a void variable)
 }
 ```
 — *end example*]
+The validity of a templated entity 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 [[dcl.pre]], can be generated for a templated entity or a
+ substatement of a constexpr if statement [[stmt.if]] within a
+  templated entity and the innermost enclosing template is not
   instantiated, or
+- no valid specialization, ignoring *static_assert-declaration*s that
+  fail, can be generated for the *compound-statement* of an
+  *expansion-statement* and there is no instantiation of it, or
+- no valid specialization, ignoring *static_assert-declaration*s that
+  fail, can be generated for a default *template-argument* and the
+  default *template-argument* is not used in any instantiation, or
+- no specialization of an alias template [[temp.alias]] is valid and no
+  specialization of the alias template is named in the program, 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 templated entity immediately
+ following its definition would be ill-formed due to a construct (other
+ than a *static_assert-declaration* that fails) 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 templated
+  entity.
 [*Note 4*:
 This can happen in situations including the following:
   it names an explicit specialization that was not declared when the
   template was defined.
 — *end note*]
 [*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*:
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name [[class.pre]]. The injected-class-name can be used
 as a *template-name* or a *type-name*. When it is used with a
+*template-argument-list*, as a *template-argument* for a type 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
 };
 ```
 — *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
   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,
 - 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), or
+- in the definition of a templated function, the name of a local class
+  [[class.local]].
 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. A template argument is equivalent to a type template
+parameter if it denotes the same type. A template argument is equivalent
+to a constant template parameter if it is an *identifier* that names a
+variable that is equivalent to the template parameter. A variable is
+equivalent to a template parameter if
 - it has the same type as the template parameter (ignoring
   cv-qualification) and
 - its initializer consists of a single *identifier* that names the
   template parameter or, recursively, such a variable.
 - 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=`,[^10] 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*:
   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~[expr.prim.id.general]
+```
+— *end example*]
+An initializer is dependent if any constituent expression
+[[intro.execution]] of the initializer is type-dependent. A placeholder
+type [[dcl.spec.auto.general]] is dependent if it designates a type
+deduced from a dependent initializer.
+A placeholder for a deduced class type [[dcl.type.class.deduct]] is
+dependent if
+- it has a dependent initializer, or
+- it refers to an alias template that is a member of the current
+  instantiation and whose *defining-type-id* is dependent after class
+  template argument deduction [[over.match.class.deduct]] and
+  substitution [[temp.alias]].
+[*Example 6*:
+``` cpp
+template<class T, class V>
+struct S { S(T); };
+template<class U>
+struct A {
+  template<class T> using X = S<T, U>;
+  template<class T> using Y = S<T, int>;
+  void f() {
+    new X(1);                   // dependent
+    new Y(1);                   // not dependent
+  }
+};
 ```
 — *end example*]
 A type is dependent if it is
 - 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 dependent placeholder type,
+- denoted by a dependent placeholder for a deduced class type,
 - denoted by a *simple-template-id* in which either the template name is
+  a template parameter or any of the template arguments is dependent
+ [[temp.dep.temp]],[^11]
+- a *pack-index-specifier*,
 - denoted by `decltype(`*expression*`)`, where *expression* is
+  type-dependent [[temp.dep.expr]], or
+- denoted by a *splice-type-specifier* in which either the
+  *splice-specifier* or *splice-specialization-specifier* is dependent
+  [[temp.dep.splice]].
 [*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*]
 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 constant 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 a pack,
+  \[*Example 1*:
+  ``` cpp
+  struct C { };
+  void g(...);            // #1
+  template <typename T>
+  void f() {
+    C arr[1];
+    auto [...e] = arr;
+    g(e...);              // calls #2
+  }
+  void g(C);              // #2
+  int main() {
+    f<int>();
+  }
+  ```
+  — *end example*]
 - 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,
+- associated by name lookup with a result binding [[dcl.contract.res]]
+  of a function whose return type is dependent,
+- a *conversion-function-id* that specifies a dependent type,
+- a name N introduced by the *for-range-declaration* of an
+  *expansion-statement* S if the type specified for N contains a
+  placeholder type and either
+  - the *expansion-initializer* of S is type-dependent or
+  - S is not an iterating expansion statement, 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
 typeid '(' type-id ')'
 '::'ₒₚₜ delete cast-expression
 '::'ₒₚₜ delete '[' ']' cast-expression
 throw assignment-expressionₒₚₜ
 noexcept '(' expression ')'
+requires-expression
+reflect-expression
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *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.
+A *pack-index-expression* is type-dependent if its *id-expression* is
+type-dependent.
+A *splice-expression* is type-dependent if its *splice-specifier* or
+*splice-specialization-specifier* is dependent [[temp.dep.splice]].
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, an expression used in a context where a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
+An *id-expression* is value-dependent if
+- it is a concept-id and its *concept-name* is dependent or any of its
+  arguments are dependent [[temp.dep.temp]],
 - it is type-dependent,
+- it is the name of a constant template parameter,
+- it is a name introduced by the *for-range-declaration* of an
+  *expansion-statement* [[stmt.expand]],
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it names a potentially-constant variable [[expr.const]] that is
 sizeof unary-expression
 sizeof '(' type-id ')'
 typeid '(' expression ')'
 typeid '(' type-id ')'
 alignof '(' type-id ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
+*type-id*, *simple-type-specifier*, or *typename-specifier* is dependent
+or the *expression* or *cast-expression* is value-dependent or any
+*expression* in the *expression-list* is value-dependent or any
+*assignment-expression* in the *braced-init-list* is value-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
+typename-specifier '(' expression-listₒₚₜ ')'
+simple-type-specifier braced-init-list
+typename-specifier braced-init-list
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
 reinterpret_cast '<' type-id '>' '(' expression ')'
+dynamic_cast '<' type-id '>' '(' expression ')'
 '(' type-id ')' cast-expression
 ```
 Expressions of the following form are value-dependent:
 ``` bnf
 sizeof '...' '(' identifier ')'
 fold-expression
 ```
+unless the *identifier* is a structured binding pack whose initializer
+is not dependent.
+A *noexcept-expression* [[expr.unary.noexcept]] is value-dependent if
+its *expression* involves a template parameter.
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
 expression [[expr.const]] succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
+A *reflect-expression* is value-dependent if
+- it is of the form `^^ reflection-name` and the *reflection-name*
+  - is a dependent qualified name,
+  - is a dependent *namespace-name*,
+  - is the name of a template parameter, or
+  - names a dependent member of the current instantiation
+    [[temp.dep.type]],
+- it is of the form `^^ type-id` and the *type-id* denotes a dependent
+  type, or
+- it is of the form `^^ id-expression` and the *id-expression* is
+  value-dependent.
+A *splice-expression* is value-dependent if its *splice-specifier* or
+*splice-specialization-specifier* is dependent [[temp.dep.splice]].
+#### Dependent splice specifiers <a id="temp.dep.splice">[[temp.dep.splice]]</a>
+A *splice-specifier* is dependent if its converted *constant-expression*
+is value-dependent. A *splice-specialization-specifier* is dependent if
+its *splice-specifier* is dependent or if any of its template arguments
+are dependent. A *splice-scope-specifier* is dependent if its
+*splice-specifier* or *splice-specialization-specifier* is dependent.
+[*Example 1*:
+``` cpp
+template<auto T, auto NS>
+void fn() {
+  using a = [:T:]<1>;                           // [:T:]<1> is dependent because [:T:] is dependent
+  static_assert([:NS:]::template TCls<1>::v == a::v);   // [:NS:] is dependent
+}
+namespace N {
+  template <auto V> struct TCls { static constexpr int v = V; };
+}
+int main() {
+  fn<^^N::TCls, ^^N>();
+}
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+template<template<class> class X>
+struct S {
+  [:^^X:]<int, float> m;
+};
+template<class> struct V1 {};
+template<class, class = int> struct V2 {};
+S<V1> s1;                       // error: V1<int, float> has too many template arguments
+S<V2> s2;                       // OK
+```
+— *end example*]
+#### Dependent namespaces <a id="temp.dep.namespace">[[temp.dep.namespace]]</a>
+A namespace alias is dependent if it is introduced by a
+*namespace-alias-definition* whose *qualified-namespace-specifier* (if
+any) is a dependent qualified name or whose *splice-specifier* (if any)
+is dependent. A *namespace-name* is dependent if it names a dependent
+namespace alias.
+[*Example 1*:
+``` cpp
+template<std::meta::info R>
+int fn() {
+  namespace Alias = [:R:];          // [:R:] is dependent
+  return typename Alias::T{};       // Alias is dependent
+}
+namespace NS {
+  using T = int;
+}
+int a = fn<^^NS>();
+```
+— *end example*]
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
+A constant *template-argument* is dependent if its type is dependent or
 the constant expression it specifies is value-dependent.
+Furthermore, a constant *template-argument* is dependent if the
+corresponding constant 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 argument is also dependent if it is a pack expansion.
+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>
 template may have points of instantiation in multiple translation units.
 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.
+For the *compound-statement* of an *expansion-statement*
+[[stmt.expand]], the point of instantiation is the point of
+instantiation of its enclosing templated entity, if any. Otherwise, it
+immediately follows the namespace-scope declaration or definition that
+contains the expansion statement.
 #### 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
 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, the function
+explicitly specialized may be specified using a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct A {
 };
 ```
 — *end example*]
+If a 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 or static data member of a templated class, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
 }
 ```
 — *end example*]
+The *noexcept-specifier* and *function-contract-specifier*s of a
+function template specialization are not instantiated along with the
+function declaration; they are instantiated when needed
+[[except.spec]], [[dcl.contract.func]]. If such a specifier is needed
 but has not yet been instantiated, the dependent names are looked up,
 the semantics constraints are checked, and the instantiation of any
+template used in the specifier is done as if it were being done as part
+of instantiating the declaration of the specialization at that point.
 [*Note 6*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
 template<class T> void sort(Array<T>& v) { ... }
+template void sort(Array<char>&);       // argument is deduced here[temp.arg.explicit]
 namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 produced by the corresponding substitution into the templated function,
 variable, or class are two declarations of the same entity.
 [*Note 1*:
+These declarations need to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
 ``` cpp
 template float var<float>;      // OK, instantiated variable has type float
 template int var<int[16]>[];    // OK, absence of major array bound is permitted
 template int *var<int>;         // error: instantiated variable has type int
 template<typename T> auto av = T();
+template int av<int>;           // OK, variable with type auto can be redeclared with type int
 template<typename T> auto f() {}
 template void f<int>();         // error: function with deduced return type
                                 // redeclared with non-deduced return type[dcl.spec.auto]
 ```
 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.
+[*Note 2*: An explicit instantiation of a constrained template needs 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
 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 3*:
 ``` 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.
 [*Example 1*:
 ``` cpp
 template<class T> class stream;
+template<> class stream<char> { ... };    // #1
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
+template<> void sort<int>(Array<int>&);         // #2
+template<> void sort(Array<char*>&);            // #3 template argument is deduced[temp.arg.explicit]
 ```
+Given these declarations, \#1 will be used as the definition of streams
+of `char`s; other streams will be handled by class template
+specializations instantiated from the class template. Similarly, \#2
+will be used as the sort function for arguments of type `Array<int>` and
+\#3 will be used for arguments of type `Array<char*>`; other `Array`
+types will be sorted by functions generated from the function template.
 — *end example*]
 The *declaration* in an *explicit-specialization* shall not be an
 *export-declaration*. An explicit specialization shall not use a
 [[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
+needed. — *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.
 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.
+[*Note 2*:
+A class template explicit specialization that has been declared but not
+defined can be used exactly like other incompletely-defined classes
 [[basic.types]].
 [*Example 5*:
 ``` cpp
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
+— *end note*]
+[*Note 3*: An explicit specialization of a constrained template needs
+to satisfy that template’s associated constraints [[temp.constr.decl]].
+The satisfaction of constraints is determined when forming the template
+name of an explicit specialization in which all template arguments are
+specified [[temp.names]], or, for explicit specializations of function
+templates, during template argument deduction [[temp.deduct.decl]] when
+one or more trailing template 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, constinit, or consteval is determined by the explicit
 specialization and is independent of those properties of the template.
+Similarly, attributes and *function-contract-specifier*s appearing in
+the declaration of a template have no effect on an explicit
+specialization of that template.
+[*Example 6*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
 An explicit specialization of a static data member of a template or an
 explicit specialization of a static data member template is a definition
 if the declaration includes an initializer; otherwise, it is a
 declaration.
+[*Note 4*:
 The definition of a static data member of a template for which
 default-initialization is desired can use functional cast notation
 [[expr.type.conv]]:
 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 7*:
 ``` 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 8*:
 ``` 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 9*:
 ``` 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 5*: 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>
 ```
 — *end note*]
 Template arguments that are present shall be specified in the
+declaration order of their corresponding template parameters. The
 template argument list shall not specify more *template-argument*s than
 there are corresponding *template-parameter*s unless one of the
+*template-parameter*s declares a template parameter pack.
 [*Example 3*:
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
 — *end example*]
 Implicit conversions [[conv]] will be performed on a function argument
 to convert it to the type of the corresponding function parameter if the
+parameter type contains no template parameters that participate in
 template argument deduction.
 [*Note 3*:
 Template parameters do not participate in template argument deduction if
 ```
 — *end example*]
 When an explicit template argument list is specified, if the given
+*template-id* or *splice-specialization-specifier* is not valid
+[[temp.names]], type deduction fails. Otherwise, the specified template
+argument values are substituted for the corresponding template
+parameters as specified below.
 After this substitution is performed, the function parameter type
 adjustments described in  [[dcl.fct]] are performed.
 [*Example 2*: A parameter type of “`void (const int, int[5])`” becomes
 arguments are substituted.
 The *deduction substitution loci* are
 - the function type outside of the *noexcept-specifier*,
+- the *explicit-specifier*,
+- the template parameter declarations, and
+- the template argument list of a partial specialization
+  [[temp.spec.partial.general]].
 The substitution occurs in all types and expressions that are used in
 the deduction substitution loci. The expressions include not only
 constant expressions such as those that appear in array bounds or as
+constant template arguments but also general expressions (i.e.,
 non-constant expressions) inside `sizeof`, `decltype`, and other
 contexts that allow non-constant expressions. The substitution proceeds
 in lexical order and stops when a condition that causes deduction to
 fail is encountered. If substitution into different declarations of the
 same function template would cause template instantiations to occur in a
 different order or not at all, the program is ill-formed; no diagnostic
 required.
+[*Note 4*: The equivalent substitution in exception specifications
+[[except.spec]] and function contract assertions [[dcl.contract.func]]
+is done only when the *noexcept-specifier* or
+*function-contract-specifier*, respectively, is instantiated, at which
+point a program is ill-formed if the substitution results in an invalid
+type or expression. — *end note*]
 [*Example 6*:
 ``` cpp
 template <class T> struct A { using X = typename T::X; };
 and/or function template specializations, the generation of
 implicitly-defined functions, etc. Such effects are not in the
 “immediate context” and can result in the program being
 ill-formed. — *end note*]
+When substituting into a *lambda-expression*, substitution into its body
+is not in the immediate context.
 [*Note 7*:
 The intent is to avoid requiring implementations to deal with
 substitution failure involving arbitrary statements.
   *qualified-id* when that type does not contain the specified member,
   or
   - the specified member is not a type where a type is required, or
   - the specified member is not a template where a template is required,
     or
+  - the specified member is not a non-type, non-template where a
+    non-type, non-template is required.
   \[*Example 11*:
   ``` cpp
   template <int I> struct X { };
   template <template <class T> class> struct Z { };
   int main() {
     // Deduction fails in each of these cases:
     f<A>(0);          // A does not contain a member Y
     f<B>(0);          // The Y member of B is not a type
+    g<C>(0);          // The N member of C is not a non-type, non-template name
     h<D>(0);          // The TT member of D is not a template
   }
   ```
   — *end example*]
   template <class T> int f(int T::*);
   int i = f<int>(0);
   ```
   — *end example*]
+- Attempting to give an invalid type to a constant template parameter.
   \[*Example 13*:
   ``` cpp
   template <class T, T> struct S {};
   template <class T> int f(S<T, T{}>*);   // #1
   class X {
     int m;
   };
+  int i0 = f<X>(0);   // #1 uses a value of non-structural type X as a constant template argument
   ```
   — *end example*]
 - Attempting to perform an invalid conversion in either a template
   argument expression, or an expression used in the function
   — *end example*]
 - Attempting to create a function type in which a parameter has a type
   of `void`, or in which the return type is a function type or array
   type.
+- Attempting to give to an explicit object parameter of a lambda’s
+  function call operator a type not permitted for such
+  [[expr.prim.lambda.closure]].
 — *end note*]
 [*Example 15*:
 — *end example*]
 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
+parameter type (call it `P`) that contains template parameters that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
+$\tcode{std::initializer_list<P}^{\prime}\tcode{>}$ or `P`'`[N]` for
+some `P`' and `N` and the argument is a non-empty initializer list
+[[dcl.init.list]], then deduction is performed instead for each element
+of the initializer list independently, taking `P`' as separate function
+template parameter types `P`'_i and the iᵗʰ initializer element as the
+corresponding argument. In the `P`'`[N]` case, if `N` is a constant
+template parameter, `N` is deduced from the length of the initializer
+list. Otherwise, an initializer list argument causes the parameter to be
+considered a non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
+- If `P` is a class and `P` has the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, then the transformed
+  `A` can be a derived class `D` of the deduced `A`. Likewise, if `P` is
+ a pointer to a class of the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, the transformed `A`
+ can be a pointer to a derived class `D` of the class pointed to by the
+ deduced `A`. However, if there is a class `C` that is a (direct or
+ indirect) base class of `D` and derived (directly or indirectly) from
+ a class `B` and that would be a valid deduced `A`, the deduced `A`
+  cannot be `B` or pointer to `B`, respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
+[*Note 1*: If a template parameter is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
+  members of the set whose associated constraints [[temp.constr.constr]]
+ are satisfied. If all successful deductions yield the same deduced
+ `A`, that deduced `A` is the result of deduction; otherwise, the
+  parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
+[*Example 9*:
+``` cpp
+// All arguments for placeholder type deduction[dcl.type.auto.deduct] yield the same deduced type.
+template<bool B> struct X {
+  static void f(short) requires B;  // #1
+  static void f(short);             // #2
+};
+void test() {
+  auto x = &X<true>::f;     // OK, deduces void(*)(short), selects #1
+  auto y = &X<false>::f;    // OK, deduces void(*)(short), selects #2
+}
+```
+— *end example*]
 #### Deducing template arguments taking the address of a function template <a id="temp.deduct.funcaddr">[[temp.deduct.funcaddr]]</a>
 Template arguments can be deduced from the type specified when taking
 the address of an overload set [[over.over]]. If there is a target, the
 function template’s function type and the target type are used as the
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
+  parameter types for which the function call has arguments.[^12]
 - In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts [[temp.func.order]] the function template’s function
   type is used.
 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
+value for a constant template parameter, or a template for a template
+template parameter) that will make `P`, after substitution of the
+deduced values (call it the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
 remains neither deduced nor explicitly specified, template argument
 deduction fails. The type of a type parameter is only deduced from an
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
+templates, and constant template argument values:
 - A function type includes the types of each of the function parameters,
   the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
+  includes the types, templates, and constant template argument values
+ referenced by the template argument list of the specialization.
 - An array type includes the array element type and the value of the
   array bound.
+In most cases, the types, templates, and constant template argument
+values that are used to compose `P` participate in template argument
+deduction. That is, they may be used to determine the value of a
+template argument, and template argument deduction fails if the value so
+determined is not consistent with the values determined elsewhere. In
+certain contexts, however, the value does not participate in type
+deduction, but instead uses the values of template arguments that were
+either deduced elsewhere or explicitly specified. If a template
+parameter is used only in non-deduced contexts and is not explicitly
+specified, template argument deduction fails.
+[*Note 1*: Under [[temp.deduct.call]], if `P` contains no template
+parameters that appear in deduced contexts, no deduction is done, so `P`
+and `A` need not have the same form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
+- A *pack-index-specifier* or a *pack-index-expression*.
+- A *type-constraint*.
 - The *expression* of a *decltype-specifier*.
+- The *constant-expression* of a *splice-specifier*.
+- A constant template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
 - A function parameter for which the associated argument is an overload
+  set such that one or more of the following apply:
+  - functions whose associated constraints are satisfied and that do not
+    all have the same function type match the function parameter type
     (resulting in an ambiguous deduction), or
+  - no function whose associated constraints are satisfied matches the
+    function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
 }
 ```
 — *end example*]
+A type template argument `T`, a constant template argument `i`, a
+template template argument `TT` denoting a class template or an alias
+template, or a template template argument `VV` denoting a variable
+template or a concept can be deduced if `P` and `A` have one of the
+following forms:
 ``` cpp
 \opt{cv} T
 T*
 T&
 \opt{T}(\opt{T}) noexcept(\opt{i})
 \opt{T} \opt{T}::*
 \opt{TT}<T>
 \opt{TT}<i>
 \opt{TT}<TT>
+\opt{TT}<VV>
 \opt{TT}<>
 ```
 where
 - `\opt{T}` represents a type or parameter-type-list that either
   satisfies these rules recursively, is a non-deduced context in `P` or
   `A`, or is the same non-dependent type in `P` and `A`,
 - `\opt{i}` represents an expression that either is an `i`, is
   value-dependent in `P` or `A`, or has the same constant value in `P`
+  and `A`,
+- `\opt{TT}` represents either a class template or a template template
+  parameter, and
 - `noexcept(\opt{i})` represents an exception specification
   [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
   *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
   above.
 [*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
 `TT`s, deduction is not possible. — *end note*]
+Similarly, `<X>` represents template argument lists where at least one
+argument contains an X, where X is one of `T`, `i`, `TT`, or `VV`; and
+`<>` represents template argument lists where no argument contains a
+`T`, an `i`, a `TT`, or a `VV`.
+If `P` has a form that contains `<T>`, `<i>`, `<TT>`, or `<VV>`, then
+each argument Pᵢ of the respective template argument list of `P` is
+compared with the corresponding argument Aᵢ of the corresponding
+template argument list of `A`. If the template argument list of `P`
+contains a pack expansion that is not the last template argument, the
+entire template argument list is a non-deduced context. If `Pᵢ` is a
+pack expansion, then the pattern of `Pᵢ` is compared with each remaining
+argument in the template argument list of `A`. Each comparison deduces
+template arguments for subsequent positions in the template parameter
+packs expanded by `Pᵢ`. During partial ordering [[temp.deduct.partial]],
+if `Aᵢ` was originally a pack expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
+When the value of the argument corresponding to a constant template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
 — *end note*]
 [*Note 5*:
+If, in the declaration of a function template with a constant template
+parameter, the constant template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 [*Example 12*:
 — *end note*]
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
+named by the enclosing *simple-template-id* or
+*splice-specialization-specifier*, deduction fails. If `P` has a form
+that contains `[i]`, and if the type of `i` is not an integral type,
+deduction fails.[^13]
 If `P` has a form that includes `noexcept(i)` and the type of `i` is not
 `bool`, deduction fails.
 [*Example 13*:
 }
 ```
 — *end example*]
+The *template-argument* corresponding to a template template parameter
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
 [*Example 16*:
 [[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 the 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]].[^14]
 [*Example 1*:
 ``` cpp
 template<class T> T max(T a, T b) { return a>b?a:b; }
 — *end example*]
 [*Example 2*:
 Here is an example involving conversions on a function argument involved
+in template argument deduction:
 ``` cpp
 template<class T> struct B { ... };
 template<class T> struct D : public B<T> { ... };
 template<class T> void f(B<T>&);
 — *end example*]
 [*Example 3*:
 Here is an example involving conversions on a function argument not
+involved in template argument deduction:
 ``` cpp
 template<class T> void f(T*,int);       // #1
 template<class T> void f(T,char);       // #2
 [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.splice]: basic.md#basic.splice
 [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.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.mem.general]: class.md#class.mem.general
 [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.func]: expr.md#conv.func
 [conv.lval]: expr.md#conv.lval
 [conv.qual]: expr.md#conv.qual
 [dcl.align]: dcl.md#dcl.align
 [dcl.attr.grammar]: dcl.md#dcl.attr.grammar
+[dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.contract.func]: dcl.md#dcl.contract.func
+[dcl.contract.res]: dcl.md#dcl.contract.res
 [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.meaning]: dcl.md#dcl.meaning
 [dcl.pre]: dcl.md#dcl.pre
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.spec.auto.general]: dcl.md#dcl.spec.auto.general
 [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.eq]: expr.md#expr.eq
 [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.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.noexcept]: expr.md#expr.unary.noexcept
 [expr.unary.op]: expr.md#expr.unary.op
 [implimits]: limits.md#implimits
 [intro.defs]: intro.md#intro.defs
+[intro.execution]: basic.md#intro.execution
 [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.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.expand]: stmt.md#stmt.expand
 [stmt.if]: stmt.md#stmt.if
 [support.types]: support.md#support.types
 [temp]: #temp
 [temp.alias]: #temp.alias
 [temp.arg]: #temp.arg
 [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.concept]: #temp.constr.concept
 [temp.constr.constr]: #temp.constr.constr
 [temp.constr.constr.general]: #temp.constr.constr.general
 [temp.constr.decl]: #temp.constr.decl
+[temp.constr.fold]: #temp.constr.fold
 [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.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.namespace]: #temp.dep.namespace
 [temp.dep.res]: #temp.dep.res
+[temp.dep.splice]: #temp.dep.splice
 [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.type]: #temp.type
 [temp.variadic]: #temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.odr.use]: basic.md#term.odr.use
+[^1]: A `>` that encloses the *type-id* of a `dynamic_cast`,
     `static_cast`, `reinterpret_cast` or `const_cast`, or which encloses
+    the *template-argument*s of a subsequent *template-id* or
+ *splice-specialization-specifier*, is considered nested for the
+    purpose of this description.
+[^2]: There is no such ambiguity in a default *template-argument*
     because the form of the *template-parameter* determines the
     allowable forms of the *template-argument*.
+[^3]: A constraint is in disjunctive normal form when it is a
+    disjunction of clauses where each clause is a conjunction of fold
+ expanded or 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).
+[^4]: A constraint is in conjunctive normal form when it is a
+    conjunction of clauses where each clause is a disjunction of fold
+ expanded or 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).
+[^5]: The identity of enumerators is not preserved.
+[^6]: An array as a *template-parameter* decays to a pointer.
+[^7]: There is no context in which they would be used.
+[^8]: 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.
+[^9]: This includes friend function declarations.
+[^10]: Every instantiation of a class template declares a different set
     of assignment operators.
+[^11]: This includes an injected-class-name [[class.pre]] of a class
     template used without a *template-argument-list*.
+[^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` can 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

Diff to HTML by rtfpessoa