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

Files changed (1) hide show

tmp/tmpj6leptb4/{from.md → to.md} +277 -299

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

@@ -1,48 +1,48 @@
 ## Template declarations <a id="temp.decls">[[temp.decls]]</a>
-A *template-id*, that is, the *template-name* followed by a
-*template-argument-list* shall not be specified in the declaration of a
-primary template declaration.
-[*Example 1*:
-``` cpp
-template<class T1, class T2, int I> class A<T1, T2, I> { };     // error
-template<class T1, int I> void sort<T1, I>(T1 data[I]);         // error
-```
-— *end example*]
-[*Note 1*: However, this syntax is allowed in class template partial
-specializations [[temp.class.spec]]. — *end note*]
 For purposes of name lookup and instantiation, default arguments,
 *type-constraint*s, *requires-clause*s [[temp.pre]], and
 *noexcept-specifier*s of function templates and of member functions of
 class templates are considered definitions; each default argument,
 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
-definition or to any other default arguments *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
 are considered definitions.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
-A single class template `List` might provide an unbounded set of class
-definitions: one class `List<T>` for every type `T`, each describing a
-linked list of elements of type `T`. Similarly, a class template `Array`
-describing a contiguous, dynamic array might be defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
@@ -52,26 +52,25 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
-declared and that a *type-name* `T` may be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
-When a member function, a member class, a member enumeration, a static
-data member or a member template of a class template is defined outside
-of the class template definition, the member definition is defined as a
-template definition in which the *template-head* is equivalent to that
-of the class template [[temp.over.link]]. The names of the template
-parameters used in the definition of the member may be different from
-the template parameter names used in the class template definition. The
-template argument list following the class template name in the member
-definition shall name the parameters in the same order as the one used
-in the template parameter list of the member. Each template parameter
-pack shall be expanded with an ellipsis in the template argument list.
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
@@ -102,11 +101,11 @@ template<C T> struct S {
   void g();
   void h();
   template<D U> struct Inner;
 };
-template<C A> void S<A>::f() { }        // OK: template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
@@ -114,13 +113,15 @@ template<C X> template<D Y>
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
-In a redeclaration, partial specialization, explicit specialization or
-explicit instantiation of a class template, the *class-key* shall agree
-in kind with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
@@ -137,11 +138,11 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
-function might be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
@@ -190,12 +191,12 @@ v2[3] = dcomplex(7,8);                  // Array<dcomplex>::operator[]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
-template argument deduction [[over.match.class.deduct]], any deduction
-guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
@@ -221,15 +222,15 @@ S x{A()};           // x is of type S<short, int>
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
-the *simple-template-id*. A *deduction-guide* shall be declared in the
-same scope as the corresponding class template and, for a member class
-template, with the same access. Two deduction guide declarations in the
-same translation unit for the same class template shall not have
-equivalent *parameter-declaration-clause*s.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
@@ -241,13 +242,13 @@ instantiation [[temp.inst]]. For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
-A<int>::B* b1;                          // OK: requires A to be defined but not A::B
 template<class T> class A<T>::B { };
-A<int>::B  b2;                          // OK: requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
@@ -283,11 +284,11 @@ of unknown bound can have a different bound from its definition, if any.
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
-template <> int A<int>::i[] = { 1 };    // OK: 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
@@ -379,11 +380,11 @@ int main() {
 }
 ```
 — *end example*]
-A member function template shall not be virtual.
 [*Example 4*:
 ``` cpp
 template <class T> struct AA {
@@ -404,19 +405,21 @@ class B {
   virtual void f(int);
 };
 class D : public B {
   template <class T> void f(T); // does not override B::f(int)
-  void f(int i) { f<>(i); }     // overriding function that calls the template instantiation
 };
 ```
 — *end example*]
 A specialization of a conversion function template is referenced in the
 same way as a non-template conversion function that converts to the same
-type.
 [*Example 6*:
 ``` cpp
 struct A {
@@ -433,27 +436,15 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 1*: There is no syntax to form a *template-id* [[temp.names]] by
-providing an explicit template argument list [[temp.arg.explicit]] for a
-conversion function template [[class.conv.fct]]. — *end note*]
-A specialization of a conversion function template is not found by name
-lookup. Instead, any conversion function templates visible in the
-context of the use are considered. For each such operator, if argument
-deduction succeeds [[temp.deduct.conv]], the resulting specialization is
-used as if found by name lookup.
-A *using-declaration* in a derived class cannot refer to a
-specialization of a conversion function template in a base class.
-Overload resolution [[over.ics.rank]] and partial ordering
-[[temp.func.order]] are used to select the best conversion function
-among multiple specializations of conversion function templates and/or
-non-template conversion functions.
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 A *template parameter pack* is a template parameter that accepts zero or
 more template arguments.
@@ -582,94 +573,72 @@ template<class ... Args1> struct zip {
     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
-    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>{>}
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
-  void g(Args ... args) {                   // OK: Args is expanded by the function parameter pack args
-    f(const_cast<const Args*>(&args)...);   // OK: ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
-    f(h(args ...) + args ...);              // OK: first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
-The instantiation of a pack expansion that is neither a `sizeof...`
-expression nor a *fold-expression* produces a list of elements E₁, E₂,
-⋯, $\mathtt{E}_N$, where N is the number of elements in the pack
-expansion parameters. Each Eᵢ is generated by instantiating the pattern
-and replacing each pack expansion parameter with its iᵗʰ element. Such
-an element, in the context of the instantiation, is interpreted as
-follows:
-- if the pack is a template parameter pack, the element is a template
- parameter [[temp.param]] of the corresponding kind (type or non-type)
- designating the iᵗʰ corresponding type or value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
-  pack.
-All of the Eᵢ become items in the enclosing list.
-[*Note 1*: The variety of list varies with the context:
-*expression-list*, *base-specifier-list*, *template-argument-list*,
-etc. — *end note*]
-When N is zero, the instantiation of the expansion produces an empty
-list. Such an instantiation does not alter the syntactic interpretation
-of the enclosing construct, even in cases where omitting the list
-entirely would otherwise be ill-formed or would result in an ambiguity
-in the grammar.
-[*Example 6*:
-``` cpp
-template<class... T> struct X : T... { };
-template<class... T> void f(T... values) {
-  X<T...> x(values...);
-}
-template void f<>();    // OK: X<> has no base classes
-                        // x is a variable of type X<> that is value-initialized
-```
-— *end example*]
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
-an integral constant containing the number of elements in the pack it
-expands.
-The instantiation of a *fold-expression* produces:
-- `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a unary left fold,
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))` for a
-  unary right fold,
-- `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ for a
-  binary left fold, and
-- E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$ *op*
-  E`)))` for a binary right fold.
-In each case, *op* is the *fold-operator*, N is the number of elements
-in the pack expansion parameters, and each Eᵢ is generated by
-instantiating the pattern and replacing each pack expansion parameter
-with its iᵗʰ element. For a binary fold-expression, E is generated by
-instantiating the *cast-expression* that did not contain an unexpanded
-pack.
-[*Example 7*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
@@ -679,12 +648,12 @@ bool b = all(true, true, true, false);
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
-If N is zero for a unary fold-expression, the value of the expression is
-shown in [[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
@@ -692,29 +661,39 @@ shown in [[temp.fold.empty]]; if the operator is not listed in
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
-template, or a non-template function or class. For a friend function
-declaration that is not a template declaration:
-- if the name of the friend is a qualified or unqualified *template-id*,
-  the friend declaration refers to a specialization of a function
-  template, otherwise,
-- if the name of the friend is a *qualified-id* and a matching
-  non-template function is found in the specified class or namespace,
-  the friend declaration refers to that function, otherwise,
-- if the name of the friend is a *qualified-id* and a matching function
-  template is found in the specified class or namespace, the friend
-  declaration refers to the deduced specialization of that function
-  template [[temp.deduct.decl]], otherwise,
-- the name shall be an *unqualified-id* that declares (or redeclares) a
-  non-template function.
 [*Example 1*:
 ``` cpp
 template<class T> class task;
@@ -744,10 +723,19 @@ function template `preempt` as a friend; and each specialization of the
 template has the class template specialization `task<int>` as a friend,
 and has all specializations of the class template `frd` as friends.
 — *end example*]
 A friend template may be declared within a class or class template. A
 friend function template may be defined within a class or class
 template, but a friend class template may not be defined in a class or
 class template. In these cases, all specializations of the friend class
 or friend function template are friends of the class or class template
@@ -764,11 +752,11 @@ class A {
 — *end example*]
 A template friend declaration specifies that all specializations of that
 template, whether they are implicitly instantiated [[temp.inst]],
-partially specialized [[temp.class.spec]] or explicitly specialized
 [[temp.expl.spec]], are friends of the class containing the template
 friend declaration.
 [*Example 3*:
@@ -787,17 +775,17 @@ template<class T> struct A<T*> { X::Y ab; };        // OK
 A template friend declaration may declare a member of a dependent type
 to be a friend. The friend declaration shall declare a function or
 specify a type with an *elaborated-type-specifier*, in either case with
 a *nested-name-specifier* ending with a *simple-template-id*, *C*, whose
 *template-name* names a class template. The template parameters of the
-template friend declaration shall be deducible from *C* (
-[[temp.deduct.type]]). In this case, a member of a specialization *S* of
 the class template is a friend of the class granting friendship if
 deduction of the template parameters of *C* from *S* succeeds, and
 substituting the deduced template arguments into the friend declaration
-produces a declaration that would be a valid redeclaration of the member
-of the specialization.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
@@ -833,13 +821,10 @@ class C {
 };                                              // of those function templates
 ```
 — *end example*]
-[*Note 1*: A friend declaration may first declare a member of an
-enclosing namespace scope [[temp.inject]]. — *end note*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 [*Example 5*:
@@ -863,30 +848,28 @@ definition. A friend function template with a constraint that depends on
 a template parameter from an enclosing template shall be a definition.
 Such a constrained friend function or function template declaration does
 not declare the same function or function template as a declaration in
 any other scope.
-### Class template partial specializations <a id="temp.class.spec">[[temp.class.spec]]</a>
-A *primary class template* declaration is one in which the class
-template name is an identifier. A template declaration in which the
-class template name is a *simple-template-id* is a *partial
-specialization* of the class template named in the *simple-template-id*.
-A partial specialization of a class template provides an alternative
 definition of the template that is used instead of the primary
 definition when the arguments in a specialization match those given in
-the partial specialization [[temp.class.spec.match]]. The primary
-template shall be declared before any specializations of that template.
-A partial specialization shall be declared before the first use of a
-class template specialization that would make use of the partial
-specialization as the result of an implicit or explicit instantiation in
-every translation unit in which such a use occurs; no diagnostic is
-required.
-Each class template partial specialization is a distinct template and
-definitions shall be provided for the members of a template partial
-specialization [[temp.class.spec.mfunc]].
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };
@@ -900,11 +883,11 @@ The first declaration declares the primary (unspecialized) class
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 — *end example*]
-A class template partial specialization may be constrained [[temp.pre]].
 [*Example 2*:
 ``` cpp
 template<typename T> concept C = true;
@@ -921,38 +904,18 @@ specialization succeeds, while the reverse does not. \#2 is more
 specialized because the template arguments are equivalent, but the
 partial specialization is more constrained [[temp.constr.order]].
 — *end example*]
-The template parameters are specified in the angle bracket enclosed list
-that immediately follows the keyword `template`. For partial
-specializations, the template argument list is explicitly written
-immediately following the class template name. For primary templates,
-this list is implicitly described by the template parameter list.
-Specifically, the order of the template arguments is the sequence in
-which they appear in the template parameter list.
-[*Example 3*: The template argument list for the primary template in
-the example above is `<T1,` `T2,` `I>`. — *end example*]
-[*Note 1*:
-The template argument list cannot be specified in the primary template
-declaration. For example,
-``` cpp
-template<class T1, class T2, int I>
-class A<T1, T2, I> { };                         // error
-```
-— *end note*]
-A class template partial specialization may be declared in any scope in
-which the corresponding primary template may be defined (
-[[namespace.memdef]], [[class.mem]], [[temp.mem]]).
-[*Example 4*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
@@ -967,18 +930,19 @@ template<class T> template<class T2>
 A<short>::C::B<int*> absip;                     // uses partial specialization #2
 ```
 — *end example*]
-Partial specialization declarations themselves are not found by name
-lookup. Rather, when the primary template name is used, any
-previously-declared partial specializations of the primary template are
-also considered. One consequence is that a *using-declaration* which
-refers to a class template does not restrict the set of partial
-specializations which may be found through the *using-declaration*.
-[*Example 5*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
@@ -996,61 +960,61 @@ A<int,int*> a;      // uses the partial specialization, which is found through t
 — *end example*]
 A non-type argument is non-specialized if it is the name of a non-type
 parameter. All other non-type arguments are specialized.
-Within the argument list of a class template partial specialization, the
-following restrictions apply:
 - The type of a template parameter corresponding to a specialized
-  non-type argument shall not be dependent on a parameter of the
   specialization.
-  \[*Example 6*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
   template< int X, int (*array_ptr)[X] > class A {};
   int array[5];
   template< int X > class A<X,&array> { };        // error
   ```
   — *end example*]
-- The specialization shall be more specialized than the primary template
-  [[temp.class.order]].
-- The template parameter list of a specialization shall not contain
-  default template argument values.[^8]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
 to specify template arguments of the *simple-template-id* of the partial
 specialization.
-[*Note 2*: The template arguments may be private types or objects that
 would normally not be accessible. Dependent names cannot be checked when
 declaring the partial specialization, but will be checked when
 substituting into the partial specialization. — *end note*]
-#### Matching of class template partial specializations <a id="temp.class.spec.match">[[temp.class.spec.match]]</a>
-When a class template is used in a context that requires an
-instantiation of the class, it is necessary to determine whether the
-instantiation is to be generated using the primary template or one of
-the partial specializations. This is done by matching the template
-arguments of the class template specialization with the template
-argument lists of the partial specializations.
-- If exactly one matching specialization is found, the instantiation is
-  generated from that specialization.
-- If more than one matching specialization is found, the partial order
-  rules [[temp.class.order]] are used to determine whether one of the
-  specializations is more specialized than the others. If none of the
- specializations is more specialized than all of the other matching
- specializations, then the use of the class template is ambiguous and
-  the program is ill-formed.
 - If no matches are found, the instantiation is generated from the
   primary template.
 A partial specialization matches a given actual template argument list
 if the template arguments of the partial specialization can be deduced
@@ -1108,21 +1072,22 @@ template <int I, int J, int K> struct B {};
 template <int I> struct B<I, I*2, 2> {};    // OK
 ```
 — *end example*]
-In a type name that refers to a class template specialization, (e.g.,
-`A<int, int, 1>`) the argument list shall match the template parameter
-list of the primary template. The template arguments of a specialization
-are deduced from the arguments of the primary template.
-#### Partial ordering of class template specializations <a id="temp.class.order">[[temp.class.order]]</a>
-For two class template partial specializations, the first is *more
-specialized* than the second if, given the following rewrite to two
-function templates, the first function template is more specialized than
-the second according to the ordering rules for function templates
 [[temp.func.order]]:
 - Each of the two function templates has the same template parameters
   and associated constraints [[temp.constr.decl]] as the corresponding
   partial specialization.
@@ -1176,26 +1141,20 @@ template<D T> void f(S<T>);     // B
 The partial specialization \#2 is more specialized than \#1 because `B`
 is more specialized than `A`.
 — *end example*]
-#### Members of class template specializations <a id="temp.class.spec.mfunc">[[temp.class.spec.mfunc]]</a>
-The template parameter list of a member of a class template partial
-specialization shall match the template parameter list of the class
-template partial specialization. The template argument list of a member
-of a class template partial specialization shall match the template
-argument list of the class template partial specialization. A class
-template partial specialization is a distinct template. The members of
-the class template partial specialization are unrelated to the members
-of the primary template. Class template partial specialization members
-that are used in a way that requires a definition shall be defined; the
-definitions of members of the primary template are never used as
-definitions for members of a class template partial specialization. An
-explicit specialization of a member of a class template partial
-specialization is declared in the same way as an explicit specialization
-of the primary template.
 [*Example 1*:
 ``` cpp
 // primary class template
@@ -1232,15 +1191,15 @@ int main() {
 — *end example*]
 If a member template of a class template is partially specialized, the
 member template partial specializations are member templates of the
 enclosing class template; if the enclosing class template is
-instantiated ([[temp.inst]], [[temp.explicit]]), a declaration for
-every member template partial specialization is also instantiated as
-part of creating the members of the class template specialization. If
-the primary member template is explicitly specialized for a given
-(implicit) specialization of the enclosing class template, the partial
 specializations of the member template are ignored for this
 specialization of the enclosing class template. If a partial
 specialization of the member template is explicitly specialized for a
 given (implicit) specialization of the enclosing class template, the
 primary member template and its other partial specializations are still
@@ -1263,28 +1222,33 @@ A<char>::B<int>  abci;                                          // uses #1
 — *end example*]
 ### Function templates <a id="temp.fct">[[temp.fct]]</a>
 A function template defines an unbounded set of related functions.
 [*Example 1*:
-A family of sort functions might be declared like this:
 ``` cpp
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 — *end example*]
-A function template can be overloaded with other function templates and
-with non-template functions [[dcl.fct]]. A non-template function is not
-related to a function template (i.e., it is never considered to be a
-specialization), even if it has the same name and type as a potentially
-generated function template specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
@@ -1319,17 +1283,17 @@ names of the template parameters are significant only for establishing
 the relationship between the template parameters and the rest of the
 signature.
 [*Note 1*:
-Two distinct function templates may have identical function return types
 and function parameter lists, even if overload resolution alone cannot
 distinguish them.
 ``` cpp
 template<class T> void f();
-template<int I> void f();       // OK: overloads the first template
                                 // distinguishable with an explicit template argument list
 ```
 — *end note*]
@@ -1366,25 +1330,27 @@ another token that names the same template parameter in the other
 expression. Two unevaluated operands that do not involve template
 parameters are considered equivalent if two function definitions
 containing the expressions would satisfy the one-definition rule, except
 that the tokens used to name types and declarations may differ as long
 as they name the same entities, and the tokens used to form concept-ids
-may differ as long as the two *template-id*s are the same [[temp.type]].
 [*Note 3*: For instance, `A<42>` and `A<40+2>` name the same
 type. — *end note*]
 Two *lambda-expression*s are never considered equivalent.
 [*Note 4*: The intent is to avoid *lambda-expression*s appearing in the
 signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
-only the name itself is considered, not the result of name lookup in the
-context of the template. If multiple declarations of the same function
-template differ in the result of this name lookup, the result for the
-first declaration is used.
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
@@ -1393,11 +1359,11 @@ template <int K, int L> void f(A<K+L>);         // same as #1
 template <class T> decltype(g(T())) h();
 int g(int);
 template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup…
   { return g(T()); }                            // …{} although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
-                                                // was not in scope at the first declaration of h()
 // ill-formed, no diagnostic required: the two expressions are functionally equivalent but not equivalent
 template <int N> void foo(const char (*s)[([]{}, N)]);
 template <int N> void foo(const char (*s)[([]{}, N)]);
@@ -1414,13 +1380,25 @@ of template arguments, the evaluation of the expression results in the
 same value. Two unevaluated operands that are not equivalent are
 functionally equivalent if, for any given set of template arguments, the
 expressions perform the same operations in the same order with the same
 entities.
-[*Note 5*: For instance, one could have redundant
 parentheses. — *end note*]
 Two *template-head*s are *equivalent* if their
 *template-parameter-list*s have the same length, corresponding
 *template-parameter*s are equivalent and are both declared with
 *type-constraint*s that are equivalent if either *template-parameter* is
 declared with a *type-constraint*, and if either *template-head* has a
@@ -1440,25 +1418,24 @@ When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
-Two function templates are *equivalent* if they are declared in the same
-scope, have the same name, have equivalent *template-head*s, and have
-return types, parameter lists, and trailing *requires-clause*s (if any)
-that are equivalent using the rules described above to compare
-expressions involving template parameters. Two function templates are
-*functionally equivalent* if they are declared in the same scope, have
-the same name, accept and are satisfied by the same set of template
-argument lists, and have return types and parameter lists that are
-functionally equivalent using the rules described above to compare
-expressions involving template parameters. If the validity or meaning of
-the program depends on whether two constructs are equivalent, and they
-are functionally equivalent but not equivalent, the program is
-ill-formed, no diagnostic required.
-[*Note 6*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
@@ -1480,24 +1457,23 @@ template <int I> void f(A<I>, A<I+1+2+3+4>);
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
-If a function template is overloaded, the use of a function template
-specialization might be ambiguous because template argument deduction
-[[temp.deduct]] may associate the function template specialization with
-more than one function template declaration. *Partial ordering* of
-overloaded function template declarations is used in the following
-contexts to select the function template to which a function template
-specialization refers:
 - during overload resolution for a call to a function template
   specialization [[over.match.best]];
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
-  specialization is selected to match a placement operator new (
-  [[basic.stc.dynamic.deallocation]], [[expr.new]]);
 - when a friend function declaration [[temp.friend]], an explicit
   instantiation [[temp.explicit]] or an explicit specialization
   [[temp.expl.spec]] refers to a function template specialization.
 Partial ordering selects which of two function templates is more
@@ -1647,12 +1623,12 @@ template<class T, class... U> void f(T, U...);          // #1
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
-  f(&i);                                                // OK: calls #2
-  g(&i);                                                // OK: calls #3
 }
 ```
 — *end example*]
@@ -1702,20 +1678,20 @@ template <typename T> concept C = True<T>;
 void f(C auto &, auto &) = delete;
 template <C Q> void f(Q &, C auto &);
 void g(struct A *ap, struct B *bp) {
-  f(*ap, *bp);                  // OK: Can use different methods to produce template parameters
 }
 template <typename T, typename U> struct X {};
 template <typename T, C U, typename V> bool operator==(X<T, U>, V) = delete;
 template <C T, C U, C V>               bool operator==(T, X<U, V>);
 void h() {
-  X<void *, int>{} == 0;        // OK: Correspondence of [T, U, V] and [U, V, T]
 }
 ```
 — *end example*]
@@ -1736,11 +1712,11 @@ it is equivalent to the associated type obtained by substitution of its
 [*Example 1*:
 ``` cpp
 template<class T> struct Alloc { ... };
 template<class T> using Vec = vector<T, Alloc<T>>;
-Vec<int> v;         // same as vector<int, Alloc<int>{> v;}
 template<class T>
   void process(Vec<T>& v)
   { ... }
@@ -1753,11 +1729,11 @@ template<template<class> class TT>
 f(v);               // error: Vec not deduced
 template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
-g(v);               // OK: TT = vector
 ```
 — *end example*]
 However, if the *template-id* is dependent, subsequent template argument
@@ -1809,20 +1785,21 @@ template <class T>
 A *concept* is a template that defines constraints on its template
 arguments.
 ``` bnf
 concept-definition:
-  concept concept-name '=' constraint-expression ';'
 ```
 ``` bnf
 concept-name:
   identifier
 ```
 A *concept-definition* declares a concept. Its *identifier* becomes a
-*concept-name* referring to that concept within its scope.
 [*Example 1*:
 ``` cpp
 template<typename T>
@@ -1838,20 +1815,21 @@ template<C T>       // C, as a type-constraint, constrains f2(T)
 T f2(T x) { return x; }
 ```
 — *end example*]
-A *concept-definition* shall appear at namespace scope
 [[basic.scope.namespace]].
 A concept shall not have associated constraints [[temp.constr.decl]].
 A concept is not instantiated [[temp.spec]].
 [*Note 1*: A concept-id [[temp.names]] is evaluated as an expression. A
 concept cannot be explicitly instantiated [[temp.explicit]], explicitly
-specialized [[temp.expl.spec]], or partially specialized. — *end note*]
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its

 ## Template declarations <a id="temp.decls">[[temp.decls]]</a>
+### General <a id="temp.decls.general">[[temp.decls.general]]</a>
+The template parameters of a template are specified in the angle bracket
+enclosed list that immediately follows the keyword `template`.
+A *primary template* declaration is one in which the name of the
+template is not followed by a *template-argument-list*. The template
+argument list of a primary template is the template argument list of its
+*template-head* [[temp.arg]]. A template declaration in which the name
+of the template is followed by a *template-argument-list* is a partial
+specialization [[temp.spec.partial]] of the template named in the
+declaration, which shall be a class or variable template.
 For purposes of name lookup and instantiation, default arguments,
 *type-constraint*s, *requires-clause*s [[temp.pre]], and
 *noexcept-specifier*s of function templates and of member functions of
 class templates are considered definitions; each default argument,
 *type-constraint*, *requires-clause*, or *noexcept-specifier* is a
 separate definition which is unrelated to the templated function
+definition or to any other default arguments, *type-constraint*s,
 *requires-clause*s, or *noexcept-specifier*s. For the purpose of
 instantiation, the substatements of a constexpr if statement [[stmt.if]]
 are considered definitions.
 Because an *alias-declaration* cannot declare a *template-id*, it is not
 possible to partially or explicitly specialize an alias template.
 ### Class templates <a id="temp.class">[[temp.class]]</a>
+#### General <a id="temp.class.general">[[temp.class.general]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
+It is possible for a single class template `List` to provide an
+unbounded set of class definitions: one class `List<T>` for every type
+`T`, each describing a linked list of elements of type `T`. Similarly, a
+class template `Array` describing a contiguous, dynamic array can be
+defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
+declared and that a *type-name* `T` can be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
+[*Note 1*:
+When a member of a class template is defined outside of the class
+template definition, the member definition is defined as a template
+definition with the *template-head* equivalent to that of the class
+template. The names of the template parameters used in the definition of
+the member can differ from the template parameter names used in the
+class template definition. The class template name in the member
+definition is followed by the template argument list of the
+*template-head* [[temp.arg]].
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
   void g();
   void h();
   template<D U> struct Inner;
 };
+template<C A> void S<A>::f() { }        // OK, template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
+— *end note*]
+In a partial specialization, explicit specialization or explicit
+instantiation of a class template, the *class-key* shall agree in kind
+with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
+function can be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
+template argument deduction [[over.match.class.deduct]], all reachable
+deduction guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
+the *simple-template-id*. A *deduction-guide* shall inhabit the scope to
+which the corresponding class template belongs and, for a member class
+template, have the same access. Two deduction guide declarations for the
+same class template shall not have equivalent
+*parameter-declaration-clause*s if either is reachable from the other.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
 ``` cpp
 template<class T> struct A {
   class B;
 };
+A<int>::B* b1;                          // OK, requires A to be defined but not A::B
 template<class T> class A<T>::B { };
+A<int>::B  b2;                          // OK, requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
+template <> int A<int>::i[] = { 1 };    // OK, 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
 }
 ```
 — *end example*]
+A member function template shall not be declared `virtual`.
 [*Example 4*:
 ``` cpp
 template <class T> struct AA {
   virtual void f(int);
 };
 class D : public B {
   template <class T> void f(T); // does not override B::f(int)
+  void f(int i) { f<>(i); }     // overriding function that calls the function template specialization
 };
 ```
 — *end example*]
+[*Note 1*:
 A specialization of a conversion function template is referenced in the
 same way as a non-template conversion function that converts to the same
+type [[class.conv.fct]].
 [*Example 6*:
 ``` cpp
 struct A {
 }
 ```
 — *end example*]
+There is no syntax to form a *template-id* [[temp.names]] by providing
+an explicit template argument list [[temp.arg.explicit]] for a
+conversion function template.
+— *end note*]
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 A *template parameter pack* is a template parameter that accepts zero or
 more template arguments.
     typedef Tuple<Pair<Args1, Args2> ... > type;
   };
 };
 typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
+    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>>
 typedef zip<short>::with<unsigned short, unsigned>::type T2;
     // error: different number of arguments specified for Args1 and Args2
 template<class ... Args>
+  void g(Args ... args) {                   // OK, Args is expanded by the function parameter pack args
+    f(const_cast<const Args*>(&args)...);   // OK, ``Args'' and ``args'' are expanded
     f(5 ...);                               // error: pattern does not contain any packs
     f(args);                                // error: pack ``args'' is not expanded
+    f(h(args ...) + args ...);              // OK, first ``args'' expanded within h,
                                             // second ``args'' expanded within f
   }
 ```
 — *end example*]
+The instantiation of a pack expansion considers items
+`E₁`, `E₂`, …, `E_N`, where N is the number of elements in the pack
+expansion parameters. Each `Eᵢ` is generated by instantiating the
+pattern and replacing each pack expansion parameter with its iᵗʰ
+element. Such an element, in the context of the instantiation, is
+interpreted as follows:
+- if the pack is a template parameter pack, the element is an
+ *id-expression* (for a non-type template parameter pack), a
+ *typedef-name* (for a type template parameter pack declared without
+  `template`), or a *template-name* (for a type template parameter pack
+  declared with `template`), designating the iᵗʰ corresponding type or
+  value template argument;
 - if the pack is a function parameter pack, the element is an
   *id-expression* designating the iᵗʰ function parameter that resulted
   from instantiation of the function parameter pack declaration;
   otherwise
 - if the pack is an *init-capture* pack, the element is an
   *id-expression* designating the variable introduced by the iᵗʰ
   *init-capture* that resulted from instantiation of the *init-capture*
+  pack declaration.
+When N is zero, the instantiation of a pack expansion does not alter the
+syntactic interpretation of the enclosing construct, even in cases where
+omitting the pack expansion entirely would otherwise be ill-formed or
+would result in an ambiguity in the grammar.
 The instantiation of a `sizeof...` expression [[expr.sizeof]] produces
+an integral constant with value N.
+The instantiation of a *fold-expression* [[expr.prim.fold]] produces:
+- `(` `((`E₁ *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for a unary
+  left fold,
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* $\mathtt{E}_N$`))`
+ `)` for a unary right fold,
+- `(` `(((`E *op* E₁`)` *op* E₂`)` *op* ⋯`)` *op* $\mathtt{E}_N$ `)` for
+  a binary left fold, and
+- `(` E₁ *op* `(`⋯ *op* `(`$\mathtt{E}_{N-1}$ *op* `(`$\mathtt{E}_{N}$
+  *op* E`)))` `)` for a binary right fold.
+In each case, *op* is the *fold-operator*. For a binary fold, E is
+generated by instantiating the *cast-expression* that did not contain an
+unexpanded pack.
+[*Example 6*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
 Within the instantiation of `all`, the returned expression expands to
 `((true && true) && true) && false`, which evaluates to `false`.
 — *end example*]
+If N is zero for a unary fold, the value of the expression is shown in
+[[temp.fold.empty]]; if the operator is not listed in
 [[temp.fold.empty]], the instantiation is ill-formed.
 **Table: Value of folding empty sequences** <a id="temp.fold.empty">[temp.fold.empty]</a>
 | Operator | Value when pack is empty |
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
+The instantiation of any other pack expansion produces a list of
+elements `E₁`, `E₂`, …, `E_N`.
+[*Note 1*: The variety of list varies with the context:
+*expression-list*, *base-specifier-list*, *template-argument-list*,
+etc. — *end note*]
+When N is zero, the instantiation of the expansion produces an empty
+list.
+[*Example 7*:
+``` cpp
+template<class... T> struct X : T... { };
+template<class... T> void f(T... values) {
+  X<T...> x(values...);
+}
+template void f<>();    // OK, X<> has no base classes
+                        // x is a variable of type X<> that is value-initialized
+```
+— *end example*]
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
+template, or a non-template function or class.
 [*Example 1*:
 ``` cpp
 template<class T> class task;
 template has the class template specialization `task<int>` as a friend,
 and has all specializations of the class template `frd` as friends.
 — *end example*]
+Friend classes, class templates, functions, or function templates can be
+declared within a class template. When a template is instantiated, its
+friend declarations are found by name lookup as if the specialization
+had been explicitly declared at its point of instantiation.
+[*Note 1*: They can introduce entities that belong to an enclosing
+namespace scope [[dcl.meaning]], in which case they are attached to the
+same module as the class template [[module.unit]]. — *end note*]
 A friend template may be declared within a class or class template. A
 friend function template may be defined within a class or class
 template, but a friend class template may not be defined in a class or
 class template. In these cases, all specializations of the friend class
 or friend function template are friends of the class or class template
 — *end example*]
 A template friend declaration specifies that all specializations of that
 template, whether they are implicitly instantiated [[temp.inst]],
+partially specialized [[temp.spec.partial]] or explicitly specialized
 [[temp.expl.spec]], are friends of the class containing the template
 friend declaration.
 [*Example 3*:
 A template friend declaration may declare a member of a dependent type
 to be a friend. The friend declaration shall declare a function or
 specify a type with an *elaborated-type-specifier*, in either case with
 a *nested-name-specifier* ending with a *simple-template-id*, *C*, whose
 *template-name* names a class template. The template parameters of the
+template friend declaration shall be deducible from *C*
+[[temp.deduct.type]]. In this case, a member of a specialization *S* of
 the class template is a friend of the class granting friendship if
 deduction of the template parameters of *C* from *S* succeeds, and
 substituting the deduced template arguments into the friend declaration
+produces a declaration that corresponds to the member of the
+specialization.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
 };                                              // of those function templates
 ```
 — *end example*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 [*Example 5*:
 a template parameter from an enclosing template shall be a definition.
 Such a constrained friend function or function template declaration does
 not declare the same function or function template as a declaration in
 any other scope.
+### Partial specialization <a id="temp.spec.partial">[[temp.spec.partial]]</a>
+#### General <a id="temp.spec.partial.general">[[temp.spec.partial.general]]</a>
+A partial specialization of a template provides an alternative
 definition of the template that is used instead of the primary
 definition when the arguments in a specialization match those given in
+the partial specialization [[temp.spec.partial.match]]. A declaration of
+the primary template shall precede any partial specialization of that
+template. A partial specialization shall be reachable from any use of a
+template specialization that would make use of the partial
+specialization as the result of an implicit or explicit instantiation;
+no diagnostic is required.
+Two partial specialization declarations declare the same entity if they
+are partial specializations of the same template and have equivalent
+*template-head*s and template argument lists [[temp.over.link]]. Each
+partial specialization is a distinct template.
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 — *end example*]
+A partial specialization may be constrained [[temp.constr]].
 [*Example 2*:
 ``` cpp
 template<typename T> concept C = true;
 specialized because the template arguments are equivalent, but the
 partial specialization is more constrained [[temp.constr.order]].
 — *end example*]
+The template argument list of a partial specialization is the
+*template-argument-list* following the name of the template.
+A partial specialization may be declared in any scope in which the
+corresponding primary template may be defined
+[[dcl.meaning]], [[class.mem]], [[temp.mem]].
+[*Example 3*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
 A<short>::C::B<int*> absip;                     // uses partial specialization #2
 ```
 — *end example*]
+Partial specialization declarations do not introduce a name. Instead,
+when the primary template name is used, any reachable partial
+specializations of the primary template are also considered.
+[*Note 1*: One consequence is that a *using-declaration* which refers
+to a class template does not restrict the set of partial specializations
+that are found through the *using-declaration*. — *end note*]
+[*Example 4*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
 — *end example*]
 A non-type argument is non-specialized if it is the name of a non-type
 parameter. All other non-type arguments are specialized.
+Within the argument list of a partial specialization, the following
+restrictions apply:
 - The type of a template parameter corresponding to a specialized
+  non-type argument shall not be dependent on a parameter of the partial
   specialization.
+  \[*Example 5*:
   ``` cpp
   template <class T, T t> struct C {};
   template <class T> struct C<T, 1>;              // error
   template< int X, int (*array_ptr)[X] > class A {};
   int array[5];
   template< int X > class A<X,&array> { };        // error
   ```
   — *end example*]
+- The partial specialization shall be more specialized than the primary
+ template [[temp.spec.partial.order]].
+- The template parameter list of a partial specialization shall not
+ contain default template argument values.[^8]
 - An argument shall not contain an unexpanded pack. If an argument is a
   pack expansion [[temp.variadic]], it shall be the last argument in the
   template argument list.
 The usual access checking rules do not apply to non-dependent names used
 to specify template arguments of the *simple-template-id* of the partial
 specialization.
+[*Note 2*: The template arguments can be private types or objects that
 would normally not be accessible. Dependent names cannot be checked when
 declaring the partial specialization, but will be checked when
 substituting into the partial specialization. — *end note*]
+#### Matching of partial specializations <a id="temp.spec.partial.match">[[temp.spec.partial.match]]</a>
+When a template is used in a context that requires an instantiation of
+the template, it is necessary to determine whether the instantiation is
+to be generated using the primary template or one of the partial
+specializations. This is done by matching the template arguments of the
+template specialization with the template argument lists of the partial
+specializations.
+- If exactly one matching partial specialization is found, the
+ instantiation is generated from that partial specialization.
+- If more than one matching partial specialization is found, the partial
+ order rules [[temp.spec.partial.order]] are used to determine whether
+ one of the partial specializations is more specialized than the
+ others. If such a partial specialization exists, the instantiation is
+ generated from that partial specialization; otherwise, the use of the
+ template is ambiguous and the program is ill-formed.
 - If no matches are found, the instantiation is generated from the
   primary template.
 A partial specialization matches a given actual template argument list
 if the template arguments of the partial specialization can be deduced
 template <int I> struct B<I, I*2, 2> {};    // OK
 ```
 — *end example*]
+In a name that refers to a specialization of a class or variable
+template (e.g., `A<int, int, 1>`), the argument list shall match the
+template parameter list of the primary template. The template arguments
+of a partial specialization are deduced from the arguments of the
+primary template.
+#### Partial ordering of partial specializations <a id="temp.spec.partial.order">[[temp.spec.partial.order]]</a>
+For two partial specializations, the first is *more specialized* than
+the second if, given the following rewrite to two function templates,
+the first function template is more specialized than the second
+according to the ordering rules for function templates
 [[temp.func.order]]:
 - Each of the two function templates has the same template parameters
   and associated constraints [[temp.constr.decl]] as the corresponding
   partial specialization.
 The partial specialization \#2 is more specialized than \#1 because `B`
 is more specialized than `A`.
 — *end example*]
+#### Members of class template partial specializations <a id="temp.spec.partial.member">[[temp.spec.partial.member]]</a>
+The members of the class template partial specialization are unrelated
+to the members of the primary template. Class template partial
+specialization members that are used in a way that requires a definition
+shall be defined; the definitions of members of the primary template are
+never used as definitions for members of a class template partial
+specialization. An explicit specialization of a member of a class
+template partial specialization is declared in the same way as an
+explicit specialization of a member of the primary template.
 [*Example 1*:
 ``` cpp
 // primary class template
 — *end example*]
 If a member template of a class template is partially specialized, the
 member template partial specializations are member templates of the
 enclosing class template; if the enclosing class template is
+instantiated [[temp.inst]], [[temp.explicit]], a declaration for every
+member template partial specialization is also instantiated as part of
+creating the members of the class template specialization. If the
+primary member template is explicitly specialized for a given (implicit)
+specialization of the enclosing class template, the partial
 specializations of the member template are ignored for this
 specialization of the enclosing class template. If a partial
 specialization of the member template is explicitly specialized for a
 given (implicit) specialization of the enclosing class template, the
 primary member template and its other partial specializations are still
 — *end example*]
 ### Function templates <a id="temp.fct">[[temp.fct]]</a>
+#### General <a id="temp.fct.general">[[temp.fct.general]]</a>
 A function template defines an unbounded set of related functions.
 [*Example 1*:
+A family of sort functions can be declared like this:
 ``` cpp
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 — *end example*]
+[*Note 1*: A function template can have the same name as other function
+templates and non-template functions [[dcl.fct]] in the same
+scope. — *end note*]
+A non-template function is not related to a function template (i.e., it
+is never considered to be a specialization), even if it has the same
+name and type as a potentially generated function template
+specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
 the relationship between the template parameters and the rest of the
 signature.
 [*Note 1*:
+Two distinct function templates can have identical function return types
 and function parameter lists, even if overload resolution alone cannot
 distinguish them.
 ``` cpp
 template<class T> void f();
+template<int I> void f();       // OK, overloads the first template
                                 // distinguishable with an explicit template argument list
 ```
 — *end note*]
 expression. Two unevaluated operands that do not involve template
 parameters are considered equivalent if two function definitions
 containing the expressions would satisfy the one-definition rule, except
 that the tokens used to name types and declarations may differ as long
 as they name the same entities, and the tokens used to form concept-ids
+[[temp.names]] may differ as long as the two *template-id*s are the same
+[[temp.type]].
 [*Note 3*: For instance, `A<42>` and `A<40+2>` name the same
 type. — *end note*]
 Two *lambda-expression*s are never considered equivalent.
 [*Note 4*: The intent is to avoid *lambda-expression*s appearing in the
 signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
+only the name itself is considered, not the result of name lookup.
+[*Note 5*: If such a dependent name is unqualified, it is looked up
+from the first declaration of the function template
+[[temp.dep.candidate]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <class T> decltype(g(T())) h();
 int g(int);
 template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup…
   { return g(T()); }                            // …{} although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
+                                                // not considered at the first declaration of h()
 // ill-formed, no diagnostic required: the two expressions are functionally equivalent but not equivalent
 template <int N> void foo(const char (*s)[([]{}, N)]);
 template <int N> void foo(const char (*s)[([]{}, N)]);
 same value. Two unevaluated operands that are not equivalent are
 functionally equivalent if, for any given set of template arguments, the
 expressions perform the same operations in the same order with the same
 entities.
+[*Note 6*: For instance, one could have redundant
 parentheses. — *end note*]
+[*Example 4*:
+``` cpp
+template<int I> concept C = true;
+template<typename T> struct A {
+  void f() requires C<42>;      // #1
+  void f() requires true;       // OK, different functions
+};
+```
+— *end example*]
 Two *template-head*s are *equivalent* if their
 *template-parameter-list*s have the same length, corresponding
 *template-parameter*s are equivalent and are both declared with
 *type-constraint*s that are equivalent if either *template-parameter* is
 declared with a *type-constraint*, and if either *template-head* has a
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
+If the validity or meaning of the program depends on whether two
+constructs are equivalent, and they are functionally equivalent but not
+equivalent, the program is ill-formed, no diagnostic required.
+Furthermore, if two function templates that do not correspond
+- have the same name,
+- have corresponding signatures [[basic.scope.scope]],
+- would declare the same entity [[basic.link]] considering them to
+  correspond, and
+- accept and are satisfied by the same set of template argument lists,
+the program is ill-formed, no diagnostic required.
+[*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
+If multiple function templates share a name, the use of that name can be
+ambiguous because template argument deduction [[temp.deduct]] may
+identify a specialization for more than one function template. *Partial
+ordering* of overloaded function template declarations is used in the
+following contexts to select the function template to which a function
+template specialization refers:
 - during overload resolution for a call to a function template
   specialization [[over.match.best]];
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
+  specialization is selected to match a placement operator new
+  [[basic.stc.dynamic.deallocation]], [[expr.new]];
 - when a friend function declaration [[temp.friend]], an explicit
   instantiation [[temp.explicit]] or an explicit specialization
   [[temp.expl.spec]] refers to a function template specialization.
 Partial ordering selects which of two function templates is more
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
+  f(&i);                                                // OK, calls #2
+  g(&i);                                                // OK, calls #3
 }
 ```
 — *end example*]
 void f(C auto &, auto &) = delete;
 template <C Q> void f(Q &, C auto &);
 void g(struct A *ap, struct B *bp) {
+  f(*ap, *bp);                  // OK, can use different methods to produce template parameters
 }
 template <typename T, typename U> struct X {};
 template <typename T, C U, typename V> bool operator==(X<T, U>, V) = delete;
 template <C T, C U, C V>               bool operator==(T, X<U, V>);
 void h() {
+  X<void *, int>{} == 0;        // OK, correspondence of [T, U, V] and [U, V, T]
 }
 ```
 — *end example*]
 [*Example 1*:
 ``` cpp
 template<class T> struct Alloc { ... };
 template<class T> using Vec = vector<T, Alloc<T>>;
+Vec<int> v;         // same as vector<int, Alloc<int>> v;
 template<class T>
   void process(Vec<T>& v)
   { ... }
 f(v);               // error: Vec not deduced
 template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
+g(v);               // OK, TT = vector
 ```
 — *end example*]
 However, if the *template-id* is dependent, subsequent template argument
 A *concept* is a template that defines constraints on its template
 arguments.
 ``` bnf
 concept-definition:
+  concept concept-name attribute-specifier-seqₒₚₜ '=' constraint-expression ';'
 ```
 ``` bnf
 concept-name:
   identifier
 ```
 A *concept-definition* declares a concept. Its *identifier* becomes a
+*concept-name* referring to that concept within its scope. The optional
+*attribute-specifier-seq* appertains to the concept.
 [*Example 1*:
 ``` cpp
 template<typename T>
 T f2(T x) { return x; }
 ```
 — *end example*]
+A *concept-definition* shall inhabit a namespace scope
 [[basic.scope.namespace]].
 A concept shall not have associated constraints [[temp.constr.decl]].
 A concept is not instantiated [[temp.spec]].
 [*Note 1*: A concept-id [[temp.names]] is evaluated as an expression. A
 concept cannot be explicitly instantiated [[temp.explicit]], explicitly
+specialized [[temp.expl.spec]], or partially specialized
+[[temp.spec.partial]]. — *end note*]
 The *constraint-expression* of a *concept-definition* is an unevaluated
 operand [[expr.context]].
 The first declared template parameter of a concept definition is its

Diff to HTML by rtfpessoa