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

Files changed (1) hide show

tmp/tmpw8u0tv68/{from.md → to.md} +439 -161

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

@@ -2,37 +2,45 @@
 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.
 ``` 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
 ```
-However, this syntax is allowed in class template partial
-specializations ([[temp.class.spec]]).
 For purposes of name lookup and instantiation, default arguments and
-*exception-specification*s of function templates and default arguments
-and *exception-specification*s of member functions of class templates
-are considered definitions; each default argument or
-*exception-specification* is a separate definition which is unrelated to
-the function template definition or to any other default arguments or
-*exception-specification*s.
 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. a single class template `List` might provide a
-common definition for list of `int`, list of `float`, and list of
-pointers to `Shape`s.
-An array class template might be declared like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
@@ -41,14 +49,16 @@ public:
   T& operator[](int);
   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` will be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 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
@@ -57,10 +67,12 @@ 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.
 ``` cpp
 template<class T1, class T2> struct A {
   void f1();
   void f2();
 };
@@ -77,20 +89,24 @@ template<class ... Types> struct B {
 template<class ... Types> void B<Types ...>::f3() { }    // OK
 template<class ... Types> void B<Types>::f4() { }        // error
 ```
 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.
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
 public:
@@ -108,46 +124,60 @@ template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 }
 ```
 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. 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[]()
 ```
 #### 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. 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<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
 ```
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
 A definition for a static data member or static data member template may
 be provided in a namespace scope enclosing the definition of the static
 member’s class template.
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
@@ -159,64 +189,80 @@ struct limits {
 template<class T>
   const T limits::min = { };    // definition
 ```
 An explicit specialization of a static data member declared as an array
 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
 ```
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>
 An enumeration member of a class template may be defined outside the
 class template definition.
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
 ### Member templates <a id="temp.mem">[[temp.mem]]</a>
 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.
 ``` cpp
 template<class T> struct string {
   template<class T2> int compare(const T2&);
-  template<class T2> string(const string<T2>& s) { /* ... */ }
 };
 template<class T> template<class T2> int string<T>::compare(const T2& s) {
 }
 ```
 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.
 ``` cpp
 template <class T> struct A {
   void f(int);
   template <class T2> void f(T2);
 };
@@ -230,38 +276,49 @@ int main() {
   ac.f('c');        // template
   ac.f<>(1);        // template
 }
 ```
 A member function template shall not be virtual.
 ``` cpp
 template <class T> struct AA {
   template <class C> virtual void g(C);     // error
   virtual void f();                         // OK
 };
 ```
 A specialization of a member function template does not override a
 virtual function from a base class.
 ``` cpp
 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
 };
 ```
 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.
 ``` cpp
 struct A {
   template <class T> operator T*();
 };
 template <class T> A::operator T*(){ return 0; }
@@ -269,20 +326,21 @@ template <> A::operator char*(){ return 0; }    // specialization
 template A::operator void*();                   // explicit instantiation
 int main() {
   A a;
   int* ip;
-  ip = a.operator int*();       // explicit call to template operator
-                                // A::operator int*()
 }
 ```
-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.
 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
@@ -299,30 +357,38 @@ 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.
 ``` cpp
 template<class ... Types> struct Tuple { };
 Tuple<> t0;                     // Types contains no arguments
 Tuple<int> t1;                  // Types contains one argument: int
 Tuple<int, float> t2;           // Types contains two arguments: int and float
 Tuple<0> error;                 // error: 0 is not a type
 ```
 A *function parameter pack* is a function parameter that accepts zero or
 more function arguments.
 ``` 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
 ```
 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
@@ -330,10 +396,12 @@ 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 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
@@ -346,43 +414,49 @@ the following contexts:
 - 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 a *dynamic-exception-specification* ([[except.spec]]); the pattern
-  is a *type-id*.
 - 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*.
 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.
-``` 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
-}
-```
 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.
 ``` cpp
 template<typename...> struct Tuple {};
 template<typename T1, typename T2> struct Pair {};
 template<class ... Args1> struct zip {
@@ -399,38 +473,46 @@ typedef zip<short>::with<unsigned short, unsigned>::type T2;
 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
   }
 ```
-The instantiation of a pack expansion that is not a `sizeof...`
-expression produces a list
-$\mathtt{E}_1, \mathtt{E}_2, ..., \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. The variety of list
-varies with the context: *expression-list*, *base-specifier-list*,
-*template-argument-list*, etc. 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.
 ``` cpp
 template<class... T> struct X : T... { };
 template<class... T> void f(T... values) {
   X<T...> x(values...);
@@ -438,14 +520,60 @@ template<class... T> void f(T... values) {
 template void f<>();    // OK: X<> has no base classes
                         // x is a variable of type X<> that is value-initialized
 ```
 The instantiation of a `sizeof...` expression ([[expr.sizeof]])
 produces an integral constant containing the number of elements in the
 parameter pack it expands.
 ### 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
@@ -462,10 +590,12 @@ declaration that is not a template declaration:
   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.
 ``` cpp
 template<class T> class task;
 template<class T> task<T>* preempt(task<T>*);
 template<class T> class task {
@@ -490,54 +620,61 @@ function template `preempt` as a friend; and each specialization of the
 `task` class template has all specializations of the function template
 `func` as friends. Similarly, each specialization of the `task` class
 template has the class template specialization `task<int>` as a friend,
 and has all specializations of the class template `frd` as friends.
 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
 granting friendship.
 ``` cpp
 class A {
   template<class T> friend class B;                 // OK
-  template<class T> friend void f(T){ /* ... */ } // OK
 };
 ```
 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.
 ``` cpp
 class X {
   template<class T> friend struct A;
   class Y { };
 };
 template<class T> struct A { X::Y ab; };            // OK
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
-When a function is defined in a friend function declaration in a class
-template, the function is instantiated when the function is odr-used (
-[[basic.def.odr]]). The same restrictions on multiple declarations and
-definitions that apply to non-template function declarations and
-definitions also apply to these implicit definitions.
 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 class template is a friend of the class granting
-friendship. For explicit 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.
 ``` cpp
 template<class T> struct A {
   struct B { };
   void f();
@@ -561,31 +698,37 @@ class C {
   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
 };
 ```
-A friend declaration may first declare a member of an enclosing
-namespace scope ([[temp.inject]]).
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 ``` cpp
 template<class T> class A { };
 class X {
   template<class T> friend class A<T*>;         // error
 };
 ```
 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
@@ -600,62 +743,81 @@ 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]]).
 ``` cpp
-template<class T1, class T2, int I> class A             { };    // #1
-template<class T, int I>            class A<T, T*, I>   { };    // #2
-template<class T1, class T2, int I> class A<T1*, T2, I> { };    // #3
-template<class T>                   class A<int, T*, 5> { };    // #4
-template<class T1, class T2, int I> class A<T1, T2*, I> { };    // #5
 ```
 The first declaration declares the primary (unspecialized) class
 template. The second and subsequent declarations declare partial
 specializations of the primary template.
 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. the template argument
-list for the primary template in the example above is `<T1,` `T2,` `I>`.
 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
 ```
-A class template partial specialization may be declared or redeclared in
-any namespace scope in which its definition may be defined (
-[[temp.class]] and  [[temp.mem]]).
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
   };
 };
 // partial specialization of A<T>::C::B<T2>
 template<class T> template<class T2>
-  struct A<T>::C::B<T2*> { };
-A<short>::C::B<int*> absip; // uses partial specialization
 ```
 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*.
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
@@ -663,43 +825,36 @@ using N::A;                             // refers to the primary template
 namespace N {
   template<class T> class A<T, T*> { };         // partial specialization
 }
-A<int,int*> a; // uses the partial specialization, which is found through
- // the using declaration which refers to the primary template
 ```
 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:
-- A partially specialized non-type argument expression shall not involve
-  a template parameter of the partial specialization except when the
-  argument expression is a simple *identifier*.
-  ``` cpp
-  template <int I, int J> struct A {};
-  template <int I> struct A<I+5, I*2> {}; // error
-  template <int I, int J> struct B {};
-  template <int I> struct B<I, I> {};     // OK
-  ```
 - The type of a template parameter corresponding to a specialized
   non-type argument shall not be dependent on a parameter of the
   specialization.
   ``` 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
   ```
-- The argument list of the specialization shall not be identical to the
- implicit argument list of the primary template.
 - 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
@@ -728,57 +883,93 @@ argument lists of the partial specializations.
 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]]).
 ``` cpp
 A<int, int, 1>   a1;            // uses #1
 A<int, int*, 1>  a2;            // uses #2, T is int, I is 1
 A<int, char*, 5> a3;            // uses #4, T is char
 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
 ```
-A non-type template argument can also be deduced from the value of an
-actual template argument of a non-type parameter of the primary
-template. the declaration of `a2` above.
 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 at least as
-specialized as the second if, given the following rewrite to two
-function templates, the first function template is at least as
-specialized as the second according to the ordering rules for function
-templates ([[temp.func.order]]):
-- the first function template has the same template parameters as the
- first partial specialization and has a single function parameter whose
-  type is a class template specialization with the template arguments of
-  the first partial specialization, and
-- the second function template has the same template parameters as the
- second partial specialization and has a single function parameter
- whose type is a class template specialization with the template
-  arguments of the second partial specialization.
 ``` cpp
 template<int I, int J, class T> class X { };
 template<int I, int J>          class X<I, J, int> { };         // #1
 template<int I>                 class X<I, I, int> { };         // #2
-template<int I, int J> void f(X<I, J, int>); // A
-template<int I> void f(X<I, I, int>); // B
 ```
-The partial specialization `#2` is more specialized than the partial
-specialization `#1` because the function template `B` is more
-specialized than the function template `A` according to the ordering
-rules for function templates.
 #### 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
@@ -793,16 +984,19 @@ 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.
 ``` cpp
-// primary template
 template<class T, int I> struct A {
   void f();
 };
 template<class T, int I> void A<T,I>::f() { }
 // class template partial specialization
 template<class T> struct A<T,2> {
   void f();
@@ -818,19 +1012,18 @@ template<> void A<char,2>::h() { }
 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
 }
 ```
 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
@@ -842,10 +1035,12 @@ 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
 considered for this specialization of the enclosing class template.
 ``` cpp
 template<class T> struct A {
   template<class T2> struct B {};                     // #1
   template<class T2> struct B<T2*> {};                // #2
 };
@@ -855,20 +1050,27 @@ template<> template<class T2> struct A<short>::B {};  // #3
 A<char>::B<int*>  abcip;  // uses #2
 A<short>::B<int*> absip;  // uses #3
 A<char>::B<int>  abci;    // uses #1
 ```
 ### Function templates <a id="temp.fct">[[temp.fct]]</a>
-A function template defines an unbounded set of related functions. a
-family of sort functions might be declared like this:
 ``` cpp
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 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]
@@ -876,76 +1078,92 @@ 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.
 ``` cpp
-// file1.c
 template<class T>
   void f(T*);
 void g(int* p) {
   f(p); // calls f<int>(int*)
 }
 ```
 ``` cpp
-// file2.c
 template<class T>
   void f(T);
 void h(int* p) {
   f(p); // calls f<int*>(int*)
 }
 ```
-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. 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
 ```
 When an expression that references a template parameter is used in the
 function parameter list or the return type in the declaration of a
 function template, the expression that references the template parameter
 is part of the signature of the function template. This is necessary to
 permit a declaration of a function template in one translation unit to
 be linked with another declaration of the function template in another
 translation unit and, conversely, to ensure that function templates that
 are intended to be distinct are not linked with one another.
 ``` cpp
 template <int I, int J> A<I+J> f(A<I>, A<J>);   // #1
 template <int K, int L> A<K+L> f(A<K>, A<L>);   // same as #1
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
-Most expressions that use template parameters use non-type template
-parameters, but it is possible for an expression to reference a type
-parameter. For example, a template type parameter can be used in the
-`sizeof` operator.
 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.
 ``` 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();
@@ -954,10 +1172,12 @@ template <class T> decltype(g(T())) h()         // redeclaration of h() uses the
   { 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()
 ```
 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
@@ -968,11 +1188,13 @@ 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 is required.
 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
@@ -990,10 +1212,12 @@ 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>);
 ```
 #### 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
@@ -1021,20 +1245,29 @@ 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. If only one of the
-function templates is a non-static member of some class `A`, that
-function template is considered to have a new first parameter inserted
-in its function parameter list. Given cv as the cv-qualifiers of the
-function template (if any), the new parameter is of type “rvalue
-reference to cv `A`” if the optional *ref-qualifier* of the function
-template is `&&`, or of type “lvalue reference to cv `A`” otherwise.
-This allows a non-static member to be ordered with respect to a
-nonmember function and for the results to be equivalent to the ordering
-of two equivalent nonmembers.
 ``` cpp
 struct A { };
 template<class T> struct B {
   template<class R> int operator*(R&);              // #1
@@ -1050,14 +1283,18 @@ int main() {
   B<A> b;
   b * a;                                            // calls #1a
 }
 ```
 Using the transformed function template’s function type, perform type
 deduction against the other template as described in
 [[temp.deduct.partial]].
 ``` cpp
 template<class T> struct A { A(); };
 template<class T> void f(T);
 template<class T> void f(T*);
@@ -1071,23 +1308,29 @@ template<class T> void h(A<T>&);
 void m() {
   const int* p;
   f(p);             // f(const T*) is more specialized than f(T) or f(T*)
   float x;
-  g(x);             // Ambiguous: g(T) or g(T&)
   A<int> z;
   h(z);             // overload resolution selects h(A<T>&)
   const A<int> z2;
   h(z2);            // h(const T&) is called because h(A<T>&) is not callable
 }
 ```
 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).
 ``` cpp
 template<class T> void f(T);                            // #1
 template<class T> void f(T*, int=1);                    // #2
 template<class T> void g(T);                            // #3
 template<class T> void g(T*, ...);                      // #4
@@ -1099,10 +1342,14 @@ int main() {
   f(ip);                                                // calls #2
   g(ip);                                                // calls #4
 }
 ```
 ``` cpp
 template<class T, class U> struct A { };
 template<class T, class U> void f(U, A<U, T>* p = 0);   // #1
 template<         class U> void f(U, A<U, U>* p = 0);   // #2
@@ -1114,10 +1361,14 @@ void h() {
   f<int>(42);                                           // error: ambiguous
   g(42);                                                // error: ambiguous
 }
 ```
 ``` cpp
 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
@@ -1126,34 +1377,42 @@ void h(int i) {
   f(&i);                                                // error: ambiguous
   g(&i);                                                // OK: calls #3
 }
 ```
 ### 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 a *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. An alias template name is never deduced.
 ``` 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)
-  { /* ... */ }
 template<class T>
   void process(vector<T, Alloc<T>>& w)
-  { /* ... */ }     // error: redefinition
 template<template<class> class TT>
   void f(TT<int>);
 f(v);               // error: Vec not deduced
@@ -1161,19 +1420,38 @@ f(v);               // error: Vec not deduced
 template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
 g(v);               // OK: TT = vector
 ```
 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.
 ``` cpp
 template <class T> struct A;
 template <class T> using B = typename A<T>::U;
 template <class T> struct A {
   typedef B<T> U;
 };
 B<short> b;         // error: instantiation of B<short> uses own type via A<short>::U
 ```

 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 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>
+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;
   T& operator[](int);
   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-parameter*s are those of the
 class template. The names of the template parameters used in the
 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 {
   void f1();
   void f2();
 };
 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.
+[*Example 1*:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
 public:
   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;
 };
 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>
 A definition for a static data member or static data member template may
 be provided in a namespace scope enclosing the definition of the static
 member’s class template.
+[*Example 1*:
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
 template<class T>
   const T limits::min = { };    // definition
 ```
+— *end example*]
 An explicit specialization of a static data member declared as an array
 of unknown bound can have a different bound from its definition, if any.
+[*Example 2*:
 ``` 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>
 An enumeration member of a class template may be defined outside the
 class template definition.
+[*Example 1*:
 ``` cpp
 template<class T> struct A {
   enum E : T;
 };
 A<int> a;
 template<class T> enum A<T>::E : T { e1, e2 };
 A<int>::E e = A<int>::e1;
 ```
+— *end example*]
 ### Member templates <a id="temp.mem">[[temp.mem]]</a>
 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 {
   template<class T2> int compare(const T2&);
+  template<class T2> string(const string<T2>& s) { ... }
 };
 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);
 };
   ac.f('c');        // template
   ac.f<>(1);        // template
 }
 ```
+— *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
 };
 ```
+— *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);
 };
 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 5*:
 ``` cpp
 struct A {
   template <class T> operator T*();
 };
 template <class T> A::operator T*(){ return 0; }
 template A::operator void*();                   // explicit instantiation
 int main() {
   A a;
   int* ip;
+  ip = a.operator int*();       // explicit call to template operator A::operator int*()
 }
 ```
+— *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
 ### Variadic templates <a id="temp.variadic">[[temp.variadic]]</a>
 A *template parameter pack* is a template parameter that accepts zero or
 more template arguments.
+[*Example 1*:
 ``` cpp
 template<class ... Types> struct Tuple { };
 Tuple<> t0;                     // Types contains no arguments
 Tuple<int> t1;                  // Types contains one argument: int
 Tuple<int, float> t2;           // Types contains two arguments: int and float
 Tuple<0> error;                 // error: 0 is not a type
 ```
+— *end example*]
 A *function parameter pack* is a function parameter that accepts zero or
 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
 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
 - 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 {};
 template<class ... Args1> struct zip {
 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*]
+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...);
 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
+  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 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); }
+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 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()`                           |
 ### 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 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;
 template<class T> task<T>* preempt(task<T>*);
 template<class T> class task {
 `task` class template has all specializations of the function template
 `func` as friends. Similarly, each specialization of the `task` class
 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
 granting friendship.
+[*Example 2*:
 ``` cpp
 class A {
   template<class T> friend class B;                 // OK
+  template<class T> friend void f(T){ ... } // OK
 };
 ```
+— *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
 class X {
   template<class T> friend struct A;
   class Y { };
 };
 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();
   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.
+[*Example 5*:
 ``` cpp
 template<class T> class A { };
 class X {
   template<class T> friend class A<T*>;         // error
 };
 ```
+— *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
 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<class T, int I>            class A<T, T*, I>   { };
+template<class T1, class T2, int I> class A<T1*, T2, I> { };
+template<class T>                   class A<int, T*, 5> { };
+template<class T1, class T2, int I> class A<T1, T2*, I> { };
 ```
 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
 ```
+— *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 3*:
 ``` cpp
 template<class T> struct A {
   struct C {
     template<class T2> struct B { };
+    template<class T2> struct B<T2**> { };      // partial specialization #1
   };
 };
 // partial specialization of A<T>::C::B<T2>
 template<class T> template<class T2>
+  struct A<T>::C::B<T2*> { };                   // #2
+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 4*:
 ``` cpp
 namespace N {
   template<class T1, class T2> class A { };     // primary template
 }
 namespace N {
   template<class T> class A<T, T*> { };         // partial specialization
 }
+A<int,int*> a; // uses the partial specialization, which is found through the using-declaration
+ // which refers to the primary template
 ```
+— *end example*]
 A non-type argument is non-specialized if it is the name of a non-type
 parameter. All other non-type arguments are specialized.
 Within the argument list of a 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
 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
+template<class T, int I>            class A<T, T*, I>   { };    // #2
+template<class T1, class T2, int I> class A<T1*, T2, I> { };    // #3
+template<class T>                   class A<int, T*, 5> { };    // #4
+template<class T1, class T2, int I> class A<T1, T2*, I> { };    // #5
 A<int, int, 1>   a1;            // uses #1
 A<int, int*, 1>  a2;            // uses #2, T is int, I is 1
 A<int, char*, 5> a3;            // uses #4, T is char
 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
+template <int I> struct A<I, I> {};         // OK
+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 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.
+[*Example 1*:
 ``` cpp
 template<int I, int J, class T> class X { };
 template<int I, int J>          class X<I, J, int> { };         // #1
 template<int I>                 class X<I, I, int> { };         // #2
+template<int I0, int J0> void f(X<I0, J0, int>); // A
+template<int I0> void f(X<I0, I0, int>); // B
+template <auto v>    class Y { };
+template <auto* p>   class Y<p> { };                            // #3
+template <auto** pp> class Y<pp> { };                           // #4
+template <auto* p0>   void g(Y<p0>);                            // C
+template <auto** pp0> void g(Y<pp0>);                           // D
 ```
+According to the ordering rules for function templates, the function
+template *B* is more specialized than the function template *A* and the
+function template *D* is more specialized than the function template
+*C*. Therefore, the partial specialization \#2 is more specialized than
+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
 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
 template<class T, int I> struct A {
   void f();
 };
+// member of primary class template
 template<class T, int I> void A<T,I>::f() { }
 // class template partial specialization
 template<class T> struct A<T,2> {
   void f();
 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*]
 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
 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
 considered for this specialization of the enclosing class template.
+[*Example 2*:
 ``` cpp
 template<class T> struct A {
   template<class T2> struct B {};                     // #1
   template<class T2> struct B<T2*> {};                // #2
 };
 A<char>::B<int*>  abcip;  // uses #2
 A<short>::B<int*> absip;  // uses #3
 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.[^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.
+[*Example 1*:
 ``` cpp
+// translation unit 1:
 template<class T>
   void f(T*);
 void g(int* p) {
   f(p); // calls f<int>(int*)
 }
 ```
 ``` cpp
+// translation unit 2:
 template<class T>
   void f(T);
 void h(int* p) {
   f(p); // calls f<int*>(int*)
 }
 ```
+— *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
+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*]
 When an expression that references a template parameter is used in the
 function parameter list or the return type in the declaration of a
 function template, the expression that references the template parameter
 is part of the signature of the function template. This is necessary to
 permit a declaration of a function template in one translation unit to
 be linked with another declaration of the function template in another
 translation unit and, conversely, to ensure that function templates that
 are intended to be distinct are not linked with one another.
+[*Example 2*:
 ``` cpp
 template <int I, int J> A<I+J> f(A<I>, A<J>);   // #1
 template <int K, int L> A<K+L> f(A<K>, A<L>);   // same as #1
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
+— *end example*]
+[*Note 2*: Most expressions that use template parameters use non-type
+template parameters, but it is possible for an expression to reference a
+type parameter. For example, a template type parameter can be used in
+the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 *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();
   { 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
 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
 // 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
 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*]
+[*Example 1*:
 ``` cpp
 struct A { };
 template<class T> struct B {
   template<class R> int operator*(R&);              // #1
   B<A> b;
   b * a;                                            // calls #1a
 }
 ```
+— *end example*]
 Using the transformed function template’s function type, perform type
 deduction against the other template as described in
 [[temp.deduct.partial]].
+[*Example 2*:
 ``` cpp
 template<class T> struct A { A(); };
 template<class T> void f(T);
 template<class T> void f(T*);
 void m() {
   const int* p;
   f(p);             // f(const T*) is more specialized than f(T) or f(T*)
   float x;
+  g(x);             // ambiguous: g(T) or g(T&)
   A<int> z;
   h(z);             // overload resolution selects h(A<T>&)
   const A<int> z2;
   h(z2);            // h(const T&) is called because h(A<T>&) is not callable
 }
 ```
+— *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*:
 ``` cpp
 template<class T> void f(T);                            // #1
 template<class T> void f(T*, int=1);                    // #2
 template<class T> void g(T);                            // #3
 template<class T> void g(T*, ...);                      // #4
   f(ip);                                                // calls #2
   g(ip);                                                // calls #4
 }
 ```
+— *end example*]
+[*Example 4*:
 ``` cpp
 template<class T, class U> struct A { };
 template<class T, class U> void f(U, A<U, T>* p = 0);   // #1
 template<         class U> void f(U, A<U, U>* p = 0);   // #2
   f<int>(42);                                           // error: ambiguous
   g(42);                                                // error: ambiguous
 }
 ```
+— *end example*]
+[*Example 5*:
 ``` cpp
 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
   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*:
 ``` 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)
+  { ... }
 template<class T>
   void process(vector<T, Alloc<T>>& w)
+  { ... }     // error: redefinition
 template<template<class> class TT>
   void f(TT<int>);
 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
+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;
 template <class T> using B = typename A<T>::U;
 template <class T> struct A {
   typedef B<T> U;
 };
 B<short> b;         // error: instantiation of B<short> uses own type via A<short>::U
 ```
+— *end example*]

Diff to HTML by rtfpessoa