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

Files changed (1) hide show

tmp/tmp3_0ziqb9/{from.md → to.md} +621 -218

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

@@ -12,20 +12,22 @@ 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 and
-*noexcept-specifier*s of function templates and default arguments and
-*noexcept-specifier*s of member functions of class templates are
-considered definitions; each default argument or *noexcept-specifier* is
-a separate definition which is unrelated to the function template
-definition or to any other default arguments 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>
@@ -58,18 +60,18 @@ 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-parameter*s are those of the
-class template. 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 {
@@ -89,16 +91,36 @@ template<class ... Types> struct B {
 template<class ... Types> void B<Types ...>::f3() { }   // OK
 template<class ... Types> void B<Types>::f4() { }       // error
 ```
 — *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.
@@ -114,50 +136,110 @@ public:
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 ```
-declares three function templates. 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];
 }
 ```
 — *end example*]
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
 which the member function is called.
 [*Example 2*:
-The *template-argument* for `Array<T>::operator[]()` will be determined
-by the `Array` to which the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
-v1[3] = 7; // Array<int>::operator[]()
-v2[3] = dcomplex(7,8); // Array<dcomplex>::operator[]()
 ```
 — *end example*]
 #### 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.
 [*Note 1*:
 The member class must be defined before its first use that requires an
-instantiation ([[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
@@ -230,13 +312,13 @@ A<int>::E e = A<int>::e1;
 A template can be declared within a class or class template; such a
 template is called a member template. A member template can be defined
 within or outside its class definition or class template definition. A
 member template of a class template that is defined outside of its class
-template definition shall be specified with the *template-parameter*s of
-the class template followed by the *template-parameter*s of the member
-template.
 [*Example 1*:
 ``` cpp
 template<class T> struct string {
@@ -248,20 +330,39 @@ template<class T> template<class T2> int string<T>::compare(const T2& s) {
 }
 ```
 — *end example*]
 A local class of non-closure type shall not have member templates.
-Access control rules (Clause  [[class.access]]) apply to member template
-names. A destructor shall not be a member template. A non-template
-member function ([[dcl.fct]]) with a given name and type and a member
-function template of the same name, which could be used to generate a
 specialization of the same type, can both be declared in a class. When
 both exist, a use of that name and type refers to the non-template
 member unless an explicit template argument list is supplied.
-[*Example 2*:
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class T2> void f(T2);
@@ -280,11 +381,11 @@ int main() {
 — *end example*]
 A member function template shall not be virtual.
-[*Example 3*:
 ``` cpp
 template <class T> struct AA {
   template <class C> virtual void g(C);             // error
   virtual void f();                                 // OK
@@ -294,11 +395,11 @@ template <class T> struct AA {
 — *end example*]
 A specialization of a member function template does not override a
 virtual function from a base class.
-[*Example 4*:
 ``` cpp
 class B {
   virtual void f(int);
 };
@@ -313,11 +414,11 @@ class D : public B {
 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 5*:
 ``` cpp
 struct A {
   template <class T> operator T*();
 };
@@ -332,27 +433,25 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 1*: Because the explicit template argument list follows the
-function template name, and because conversion member function templates
-and constructor member function templates are called without using a
-function name, there is no way to provide an explicit template argument
-list for these function templates. — *end note*]
 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>
@@ -378,84 +477,103 @@ more function arguments.
 [*Example 2*:
 ``` cpp
 template<class ... Types> void f(Types ... args);
-f();                            // OK: args contains no arguments
-f(1);                           // OK: args contains one argument: int
-f(2, 1.0);                      // OK: args contains two arguments: int and double
 ```
 — *end example*]
-A *parameter pack* is either a template parameter pack or a function
-parameter pack.
 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
 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* with a
-    *template-parameter-list*; 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* (Clause  [[class.derived]]); the pattern is
- a *base-specifier*.
-- In a *mem-initializer-list* ([[class.base.init]]) for a
   *mem-initializer* whose *mem-initializer-id* denotes a base class; the
   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]]); the pattern is a
-  *capture*.
-- 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 parameter pack.
-[*Example 3*:
 ``` 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
 }
 ```
 — *end example*]
-For the purpose of determining whether a parameter pack satisfies a rule
-regarding entities other than parameter packs, the parameter pack is
-considered to be the entity that would result from an instantiation of
-the pattern in which it appears.
-A parameter pack whose name appears within the pattern of a pack
-expansion is expanded by that pack expansion. An appearance of the name
-of a parameter pack is only expanded by the innermost enclosing pack
-expansion. The pattern of a pack expansion shall name one or more
-parameter packs that are not expanded by a nested pack expansion; such
-parameter packs are called *unexpanded parameter packs* in the pattern.
-All of the parameter packs expanded by a pack expansion shall have the
-same number of arguments specified. An appearance of a name of a
-parameter pack that is not expanded is ill-formed.
-[*Example 4*:
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
@@ -471,36 +589,40 @@ 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 parameter packs
-    f(args);                                // error: parameter 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
-$\mathtt{E}_1, \mathtt{E}_2, \dotsc, \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 ith 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 type or value from the template argument;
-  otherwise,
 - if the pack is a function parameter pack, the element is an
-  *id-expression* designating the function parameter that resulted from
- the instantiation of the pattern where the pack is declared.
-All of the Eᵢ become elements 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*]
@@ -508,11 +630,11 @@ 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 5*:
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
@@ -522,13 +644,13 @@ 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
-parameter 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
@@ -539,15 +661,15 @@ The instantiation of a *fold-expression* produces:
   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 ith element. For a binary fold-expression, E is generated by
 instantiating the *cast-expression* that did not contain an unexpanded
-parameter pack.
-[*Example 6*:
 ``` cpp
 template<typename ...Args>
   bool all(Args ...args) { return (... && args); }
@@ -558,17 +680,17 @@ 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 Table  [[tab:fold.empty]]; if the operator is not listed in
-Table  [[tab:fold.empty]], the instantiation is ill-formed.
-**Table: Value of folding empty sequences** <a id="tab:fold.empty">[tab:fold.empty]</a>
-| Operator | Value when parameter pack is empty |
-| -------- | ---------------------------------- |
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
@@ -586,11 +708,11 @@ declaration that is not a template declaration:
   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*:
@@ -641,13 +763,13 @@ 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*:
 ``` cpp
@@ -660,52 +782,63 @@ template<class T> struct A { X::Y ab; };            // OK
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 — *end example*]
-A member of a class template may be declared to be a friend of a
-non-template class. In this case, the corresponding member of every
-specialization of the primary class template and class template partial
-specializations thereof is a friend of the class granting friendship.
-For explicit specializations and specializations of partial
-specializations, the corresponding member is the member (if any) that
-has the same name, kind (type, function, class template, or function
-template), template parameters, and signature as the member of the class
-template instantiation that would otherwise have been generated.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
   struct B { };
   void f();
   struct D {
     void g();
   };
 };
 template<> struct A<int> {
   struct B { };
   int f();
   struct D {
     void g();
   };
 };
 class C {
   template<class T> friend struct A<T>::B;      // grants friendship to A<int>::B even though
                                                 // it is not a specialization of A<T>::B
   template<class T> friend void A<T>::f();      // does not grant friendship to A<int>::f()
                                                 // because its return type does not match
-  template<class T> friend void A<T>::D::g();   // does not grant friendship to A<int>::D::g()
-                                                // because A<int>::D is not a specialization of A<T>::D
-};
 ```
 — *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.
@@ -720,32 +853,40 @@ class X {
 — *end example*]
 When a friend declaration refers to a specialization of a function
 template, the function parameter declarations shall not include default
-arguments, nor shall the inline specifier be used in such a declaration.
 ### 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             { };
@@ -759,25 +900,46 @@ The first declaration declares the primary (unspecialized) class
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 — *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 2*: The template argument list for the primary template in
 the example above is `<T1,` `T2,` `I>`. — *end example*]
 [*Note 1*:
-The template argument list shall not be specified in the primary
-template declaration. For example,
 ``` cpp
 template<class T1, class T2, int I>
 class A<T1, T2, I> { };                         // error
 ```
@@ -786,11 +948,11 @@ class A<T1, T2, I> { };                         // error
 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 3*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
@@ -812,11 +974,11 @@ 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 4*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
@@ -840,28 +1002,37 @@ 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 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 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.[^4]
-- An argument shall not contain an unexpanded parameter pack. If an
- argument is a pack expansion ([[temp.variadic]]), it shall be the
- last argument in the template argument list.
 #### 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
@@ -871,21 +1042,23 @@ 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
-from the actual template argument list ([[temp.deduct]]).
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };    // #1
@@ -901,15 +1074,31 @@ A<int, char*, 1> a4;            // uses #5, T1 is int, T2 is char, I is 1
 A<int*, int*, 2> a5;                    // ambiguous: matches #3 and #5
 ```
 — *end example*]
 If the template arguments of a partial specialization cannot be deduced
 because of the structure of its *template-parameter-list* and the
 *template-id*, the program is ill-formed.
-[*Example 2*:
 ``` cpp
 template <int I, int J> struct A {};
 template <int I> struct A<I+5, I*2> {};     // error
@@ -929,15 +1118,16 @@ 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 as
- the corresponding partial specialization.
 - Each function template has a single function parameter whose type is a
   class template specialization where the template arguments are the
   corresponding template parameters from the function template for each
   template argument in the *template-argument-list* of the
   *simple-template-id* of the partial specialization.
@@ -967,21 +1157,40 @@ function template *D* is more specialized than the function template
 the partial specialization \#1 and the partial specialization \#4 is
 more specialized than the partial specialization \#3.
 — *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 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.
@@ -1014,11 +1223,11 @@ int main() {
   A<char,0> a0;
   A<char,2> a2;
   a0.f();           // OK, uses definition of primary template's member
   a2.g();           // OK, uses definition of partial specialization's member
   a2.h();           // OK, uses definition of explicit specialization's member
-  a2.f();           // ill-formed, no definition of f for A<T,2>; the primary template is not used here
 }
 ```
 — *end example*]
@@ -1068,14 +1277,14 @@ 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.[^5]
 #### 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.
@@ -1101,16 +1310,16 @@ void h(int* p) {
 ```
 — *end example*]
 Such specializations are distinct functions and do not violate the
-one-definition rule ([[basic.def.odr]]).
-The signature of a function template is defined in Clause
-[[intro.defs]]. The 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
@@ -1148,120 +1357,186 @@ 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
 *equivalent* if two function definitions containing the expressions
-would satisfy the one-definition rule ([[basic.def.odr]]), except that
-the tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 another token that names the same template parameter in the other
-expression. 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
 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()
 ```
 — *end example*]
-Two expressions involving template parameters that are not equivalent
-are *functionally equivalent* if, for any given set of template
-arguments, the evaluation of the expression results in the same value.
 Two function templates are *equivalent* if they are declared in the same
-scope, have the same name, have identical template parameter lists, and
-have return types and parameter lists that are equivalent using the
-rules described above to compare expressions involving template
-parameters. Two function templates are *functionally equivalent* if they
-are equivalent except that one or more expressions that involve template
-parameters in the return types and parameter lists are functionally
-equivalent using the rules described above to compare expressions
-involving template parameters. If a program contains declarations of
-function templates that are functionally equivalent but not equivalent,
-the program is ill-formed, no diagnostic required.
-[*Note 3*:
 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
 equivalent and would cause a program to be ill-formed:
 ``` cpp
-// Guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+10>);
-// Guaranteed to be different
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+11>);
-// Ill-formed, no diagnostic required
 template <int I> void f(A<I>, A<I+10>);
 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
 specialized than the other by transforming each template in turn (see
 next paragraph) and performing template argument deduction using the
 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.
 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*]
-If only one of the function templates *M* is a non-static member of some
-class *A*, *M* is considered to have a new first parameter inserted in
-its function parameter list. Given cv as the cv-qualifiers of *M* (if
-any), the new parameter is of type “rvalue reference to cv *A*” if the
-optional *ref-qualifier* of *M* is `&&` or if *M* has no *ref-qualifier*
-and the first parameter of the other template has rvalue reference type.
-Otherwise, the new parameter is of type “lvalue reference to cv *A*”.
 [*Note 2*: This allows a non-static member to be ordered with respect
 to a non-member function and for the results to be equivalent to the
 ordering of two equivalent non-members. — *end note*]
@@ -1279,11 +1554,11 @@ template<class T, class R> int operator*(T&, R&);   // #2
 // template<class R> int operator*(B<A>&, R&);\quad\quad\quad// #1a
 int main() {
   A a;
   B<A> b;
-  b * a;                                            // calls #1a
 }
 ```
 — *end example*]
@@ -1320,12 +1595,12 @@ void m() {
 — *end example*]
 [*Note 3*:
-Since partial ordering in a call context considers only parameters for
-which there are explicit call arguments, some parameters are ignored
 (namely, function parameter packs, parameters with default arguments,
 and ellipsis parameters).
 [*Example 3*:
@@ -1372,30 +1647,91 @@ 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);                                                // error: ambiguous
   g(&i);                                                // OK: calls #3
 }
 ```
 — *end example*]
 — *end note*]
 ### Alias templates <a id="temp.alias">[[temp.alias]]</a>
 A *template-declaration* in which the *declaration* is an
-*alias-declaration* (Clause  [[dcl.dcl]]) 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 *type-id* of
-the alias template.
 [*Note 1*: An alias template name is never deduced. — *end note*]
 [*Example 1*:
@@ -1430,19 +1766,19 @@ substitution still applies to the *template-id*.
 [*Example 2*:
 ``` cpp
 template<typename...> using void_t = void;
 template<typename T> void_t<typename T::foo> f();
-f<int>();           // error, int does not have a nested type foo
 ```
 — *end example*]
-The *type-id* in an alias template declaration shall not refer to the
-alias template being declared. The type produced by an alias template
-specialization shall not directly or indirectly make use of that
-specialization.
 [*Example 3*:
 ``` cpp
 template <class T> struct A;
@@ -1453,5 +1789,72 @@ template <class T> struct A {
 B<short> b;         // error: instantiation of B<short> uses own type via A<short>::U
 ```
 — *end example*]

 ```
 — *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>
 — *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 {
 template<class ... Types> void B<Types ...>::f3() { }   // OK
 template<class ... Types> void B<Types>::f4() { }       // error
 ```
+``` cpp
+template<typename T> concept C = true;
+template<typename T> concept D = true;
+template<C T> struct S {
+  void f();
+  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
+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.
   T& operator[](int);
   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];
 }
 ```
+A constrained member function can be defined out of line:
+``` cpp
+template<typename T> concept C = requires {
+  typename T::type;
+};
+template<typename T> struct S {
+  void f() requires C<T>;
+  void g() requires C<T>;
+};
+template<typename T>
+  void S<T>::f() requires C<T> { }      // OK
+template<typename T>
+  void S<T>::g() { }                    // error: no matching function in S<T>
+```
 — *end example*]
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
 which the member function is called.
 [*Example 2*:
+The *template-argument* for `Array<T>::operator[]` will be determined by
+the `Array` to which the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
+v1[3] = 7; // Array<int>::operator[]
+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]], any 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
+template<class T, class D = int>
+struct S {
+  T data;
+};
+template<class U>
+S(U) -> S<typename U::type>;
+struct A {
+  using type = short;
+  operator type();
+};
+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 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.
 [*Note 1*:
 The member class must be defined before its first use that requires an
+instantiation [[temp.inst]]. For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
 A template can be declared within a class or class template; such a
 template is called a member template. A member template can be defined
 within or outside its class definition or class template definition. A
 member template of a class template that is defined outside of its class
+template definition shall be specified with a *template-head* equivalent
+to that of the class template followed by a *template-head* equivalent
+to that of the member template [[temp.over.link]].
 [*Example 1*:
 ``` cpp
 template<class T> struct string {
 }
 ```
 — *end example*]
+[*Example 2*:
+``` cpp
+template<typename T> concept C1 = true;
+template<typename T> concept C2 = sizeof(T) <= 4;
+template<C1 T> struct S {
+  template<C2 U> void f(U);
+  template<C2 U> void g(U);
+};
+template<C1 T> template<C2 U>
+void S<T>::f(U) { }             // OK
+template<C1 T> template<typename U>
+void S<T>::g(U) { }             // error: no matching function in S<T>
+```
+— *end example*]
 A local class of non-closure type shall not have member templates.
+Access control rules [[class.access]] apply to member template names. A
+destructor shall not be a member template. A non-template member
+function [[dcl.fct]] with a given name and type and a member function
+template of the same name, which could be used to generate a
 specialization of the same type, can both be declared in a class. When
 both exist, a use of that name and type refers to the non-template
 member unless an explicit template argument list is supplied.
+[*Example 3*:
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class T2> void f(T2);
 — *end example*]
 A member function template shall not be virtual.
+[*Example 4*:
 ``` cpp
 template <class T> struct AA {
   template <class C> virtual void g(C);             // error
   virtual void f();                                 // OK
 — *end example*]
 A specialization of a member function template does not override a
 virtual function from a base class.
+[*Example 5*:
 ``` cpp
 class B {
   virtual void f(int);
 };
 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 {
   template <class T> operator T*();
 };
 }
 ```
 — *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>
 [*Example 2*:
 ``` cpp
 template<class ... Types> void f(Types ... args);
+f();                            // args contains no arguments
+f(1);                           // args contains one argument: int
+f(2, 1.0);                      // args contains two arguments: int and double
 ```
 — *end example*]
+An **init-capture* pack* is a lambda capture that introduces an
+*init-capture* for each of the elements in the pack expansion of its
+*initializer*.
+[*Example 3*:
+``` cpp
+template <typename... Args>
+void foo(Args... args) {
+    [...xs=args]{
+        bar(xs...);             // xs is an init-capture pack
+    };
+}
+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
 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
   *mem-initializer* whose *mem-initializer-id* denotes a base class; the
   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
 }
 ```
 — *end example*]
+For the purpose of determining whether a pack satisfies a rule regarding
+entities other than packs, the pack is considered to be the entity that
+would result from an instantiation of the pattern in which it appears.
+A pack whose name appears within the pattern of a pack expansion is
+expanded by that pack expansion. An appearance of the name of a pack is
+only expanded by the innermost enclosing pack expansion. The pattern of
+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 {};
     // 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*]
 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...);
                         // 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
   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); }
 `((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 |
+| -------- | ------------------------ |
 | `&&`     | `true`                   |
 | `||`     | `false`                  |
 | `,`      | `void()`                 |
   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*:
 ```
 — *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*:
 ``` cpp
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 — *end example*]
+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 {
   struct B { };
   void f();
   struct D {
     void g();
   };
+  T h();
+  template<T U> T i();
 };
 template<> struct A<int> {
   struct B { };
   int f();
   struct D {
     void g();
   };
+  template<int U> int i();
+};
+template<> struct A<float*> {
+  int *h();
 };
 class C {
   template<class T> friend struct A<T>::B;      // grants friendship to A<int>::B even though
                                                 // it is not a specialization of A<T>::B
   template<class T> friend void A<T>::f();      // does not grant friendship to A<int>::f()
                                                 // because its return type does not match
+  template<class T> friend void A<T>::D::g();   // error: A<T>::D does not end with a simple-template-id
+  template<class T> friend int *A<T*>::h();     // grants friendship to A<int*>::h() and A<float*>::h()
+  template<class T> template<T U>               // grants friendship to instantiations of A<T>::i() and
+    friend T A<T>::i();                         // to A<int>::i(), and thereby to all specializations
+};                                              // 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.
 — *end example*]
 When a friend declaration refers to a specialization of a function
 template, the function parameter declarations shall not include default
+arguments, nor shall the `inline`, `constexpr`, or `consteval`
+specifiers be used in such a declaration.
+A non-template friend declaration with a *requires-clause* shall be a
+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             { };
 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;
+template<typename T> struct X { };
+template<typename T> struct X<T*> { };          // #1
+template<C T> struct X<T> { };                  // #2
+```
+Both partial specializations are more specialized than the primary
+template. \#1 is more specialized because the deduction of its template
+arguments from the template argument list of the class template
+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
 ```
 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 { };
 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
 }
 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
 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
+from the actual template argument list [[temp.deduct]], and the deduced
+template arguments satisfy the associated constraints of the partial
+specialization, if any [[temp.constr.decl]].
 [*Example 1*:
 ``` cpp
 template<class T1, class T2, int I> class A             { };    // #1
 A<int*, int*, 2> a5;                    // ambiguous: matches #3 and #5
 ```
 — *end example*]
+[*Example 2*:
+``` cpp
+template<typename T> concept C = requires (T t) { t.f(); };
+template<typename T> struct S { };      // #1
+template<C T> struct S<T> { };          // #2
+struct Arg { void f(); };
+S<int> s1;                              // uses #1; the constraints of #2 are not satisfied
+S<Arg> s2;                              // uses #2; both constraints are satisfied but #2 is more specialized
+```
+— *end example*]
 If the template arguments of a partial specialization cannot be deduced
 because of the structure of its *template-parameter-list* and the
 *template-id*, the program is ill-formed.
+[*Example 3*:
 ``` cpp
 template <int I, int J> struct A {};
 template <int I> struct A<I+5, I*2> {};     // error
 #### 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.
 - Each function template has a single function parameter whose type is a
   class template specialization where the template arguments are the
   corresponding template parameters from the function template for each
   template argument in the *template-argument-list* of the
   *simple-template-id* of the partial specialization.
 the partial specialization \#1 and the partial specialization \#4 is
 more specialized than the partial specialization \#3.
 — *end example*]
+[*Example 2*:
+``` cpp
+template<typename T> concept C = requires (T t) { t.f(); };
+template<typename T> concept D = C<T> && requires (T t) { t.f(); };
+template<typename T> class S { };
+template<C T> class S<T> { };   // #1
+template<D T> class S<T> { };   // #2
+template<C T> void f(S<T>);     // A
+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.
   A<char,0> a0;
   A<char,2> a2;
   a0.f();           // OK, uses definition of primary template's member
   a2.g();           // OK, uses definition of partial specialization's member
   a2.h();           // OK, uses definition of explicit specialization's member
+  a2.f();           // error: no definition of f for A<T,2>; the primary template is not used here
 }
 ```
 — *end example*]
 ```
 — *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.
 ```
 — *end example*]
 Such specializations are distinct functions and do not violate the
+one-definition rule [[basic.def.odr]].
+The signature of a function template is defined in [[intro.defs]]. The
+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
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 *equivalent* if two function definitions containing the expressions
+would satisfy the one-definition rule [[basic.def.odr]], except that the
+tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 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
 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)]);
+// two different declarations because the non-dependent portions are not considered equivalent
+template <class T> void spam(decltype([]{}) (*s)[sizeof(T)]);
+template <class T> void spam(decltype([]{}) (*s)[sizeof(T)]);
 ```
 — *end example*]
+Two potentially-evaluated expressions involving template parameters that
+are not equivalent are *functionally equivalent* if, for any given set
+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
+*requires-clause*, they both have *requires-clause*s and the
+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.
 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
 equivalent and would cause a program to be ill-formed:
 ``` cpp
+// guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+10>);
+// guaranteed to be different
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+11>);
+// ill-formed, no diagnostic required
 template <int I> void f(A<I>, A<I+10>);
 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
 specialized than the other by transforming each template in turn (see
 next paragraph) and performing template argument deduction using the
 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
+of the function parameters in its transformed template is reversed. For
+a function template M with cv-qualifiers cv that is a member of a class
+A:
+- The type X(M) is “rvalue reference to cv A” if the optional
+  *ref-qualifier* of M is `&&` or if M has no *ref-qualifier* and the
+  positionally-corresponding parameter of the other transformed template
+  has rvalue reference type; if this determination depends recursively
+  upon whether X(M) is an rvalue reference type, it is not considered to
+  have rvalue reference type.
+- Otherwise, X(M) is “lvalue reference to cv A”.
 [*Note 2*: This allows a non-static member to be ordered with respect
 to a non-member function and for the results to be equivalent to the
 ordering of two equivalent non-members. — *end note*]
 // template<class R> int operator*(B<A>&, R&);\quad\quad\quad// #1a
 int main() {
   A a;
   B<A> b;
+  b * a;                                            // calls #1
 }
 ```
 — *end example*]
 — *end example*]
 [*Note 3*:
+Since, in a call context, such type deduction considers only parameters
+for which there are explicit call arguments, some parameters are ignored
 (namely, function parameter packs, parameters with default arguments,
 and ellipsis parameters).
 [*Example 3*:
 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*]
 — *end note*]
+If deduction against the other template succeeds for both transformed
+templates, constraints can be considered as follows:
+- If their *template-parameter-list*s (possibly including
+  *template-parameter*s invented for an abbreviated function template
+  [[dcl.fct]]) or function parameter lists differ in length, neither
+  template is more specialized than the other.
+- Otherwise:
+  - If exactly one of the templates was considered by overload
+    resolution via a rewritten candidate with reversed order of
+    parameters:
+    - If, for either template, some of the template parameters are not
+      deducible from their function parameters, neither template is more
+      specialized than the other.
+    - If there is either no reordering or more than one reordering of
+      the associated *template-parameter-list* such that
+      - the corresponding *template-parameter*s of the
+        *template-parameter-list*s are equivalent and
+      - the function parameters that positionally correspond between the
+        two templates are of the same type,
+      neither template is more specialized than the other.
+  - Otherwise, if the corresponding *template-parameter*s of the
+    *template-parameter-list*s are not equivalent [[temp.over.link]] or
+    if the function parameters that positionally correspond between the
+    two templates are not of the same type, neither template is more
+    specialized than the other.
+- Otherwise, if the context in which the partial ordering is done is
+  that of a call to a conversion function and the return types of the
+  templates are not the same, then neither template is more specialized
+  than the other.
+- Otherwise, if one template is more constrained than the other
+  [[temp.constr.order]], the more constrained template is more
+  specialized than the other.
+- Otherwise, neither template is more specialized than the other.
+[*Example 6*:
+``` cpp
+template <typename> constexpr bool True = true;
+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*]
 ### Alias templates <a id="temp.alias">[[temp.alias]]</a>
 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*:
 [*Example 2*:
 ``` cpp
 template<typename...> using void_t = void;
 template<typename T> void_t<typename T::foo> f();
+f<int>();           // error: int does not have a nested type foo
 ```
 — *end example*]
+The *defining-type-id* in an alias template declaration shall not refer
+to the alias template being declared. The type produced by an alias
+template specialization shall not directly or indirectly make use of
+that specialization.
 [*Example 3*:
 ``` cpp
 template <class T> struct A;
 B<short> b;         // error: instantiation of B<short> uses own type via A<short>::U
 ```
 — *end example*]
+The type of a *lambda-expression* appearing in an alias template
+declaration is different between instantiations of that template, even
+when the *lambda-expression* is not dependent.
+[*Example 4*:
+``` cpp
+template <class T>
+  using A = decltype([] { });   // A<int> and A<char> refer to different closure types
+```
+— *end example*]
+### Concept definitions <a id="temp.concept">[[temp.concept]]</a>
+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>
+concept C = requires(T x) {
+  { x == x } -> std::convertible_to<bool>;
+};
+template<typename T>
+  requires C<T>     // C constrains f1(T) in constraint-expression
+T f1(T x) { return x; }
+template<C T>       // C, as a type-constraint, constrains f2(T)
+T f2(T x) { return x; }
+```
+— *end example*]
+A *concept-definition* shall appear at namespace scope
+[[basic.scope.namespace]].
+A concept shall not have associated constraints [[temp.constr.decl]].
+A concept is not instantiated [[temp.spec]].
+[*Note 1*: A concept-id [[temp.names]] is evaluated as an expression. A
+concept cannot be explicitly instantiated [[temp.explicit]], explicitly
+specialized [[temp.expl.spec]], or partially specialized. — *end note*]
+The *constraint-expression* of a *concept-definition* is an unevaluated
+operand [[expr.context]].
+The first declared template parameter of a concept definition is its
+*prototype parameter*. A *type concept* is a concept whose prototype
+parameter is a type *template-parameter*.

Diff to HTML by rtfpessoa