[temp] - C++11 → C++14

Files changed (1) hide show

tmp/tmpqs4fl7w8/{from.md → to.md} +456 -301

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

@@ -17,20 +17,41 @@ template-parameter-list:
 The `>` token following the of a may be the product of replacing a
 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 The *declaration* in a *template-declaration* shall
-- declare or define a function or a class, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A *template-declaration* is
-also a definition if its *declaration* defines a function, a class, or a
-static data member.
 A *template-declaration* can appear only as a namespace scope or class
 scope declaration. In a function template declaration, the last
 component of the *declarator-id* shall not be a *template-id*. That last
 component may be an *identifier*, an *operator-function-id*, a
@@ -60,20 +81,21 @@ and must also obey the one definition rule.
 A class template shall not have the same name as any other template,
 class, function, variable, enumeration, enumerator, namespace, or type
 in the same scope ([[basic.scope]]), except as specified in (
 [[temp.class.spec]]). Except that a function template can be overloaded
-either by (non-template) functions with the same name or by other
-function templates with the same name ([[temp.over]]), a template name
-declared in namespace scope or in class scope shall be unique in that
-scope.
-A function template, member function of a class template, or static data
-member of a class template shall be defined in every translation unit in
-which it is implicitly instantiated ([[temp.inst]]) unless the
-corresponding specialization is explicitly instantiated (
-[[temp.explicit]]) in some translation unit; no diagnostic is required.
 ## Template parameters <a id="temp.param">[[temp.param]]</a>
 The syntax for *template-parameter*s is:
@@ -98,11 +120,12 @@ The `>` token following the of a may be the product of replacing a
 There is no semantic difference between `class` and `typename` in a
 *template-parameter*. `typename` followed by an *unqualified-id* names a
 template type parameter. `typename` followed by a *qualified-id* denotes
 the type in a non-type [^1] *parameter-declaration*. A storage class
-shall not be specified in a *template-parameter* declaration. A template
 parameter may be a class template. For example,
 ``` cpp
 template<class T> class myarray { /* ... */ };
@@ -227,18 +250,19 @@ default *template-argument*, each subsequent *template-parameter* shall
 either have a default *template-argument* supplied or be a template
 parameter pack. If a *template-parameter* of a primary class template or
 alias template is a template parameter pack, it shall be the last
 *template-parameter*. A template parameter pack of a function template
 shall not be followed by another template parameter unless that template
-parameter can be deduced or has a default argument ([[temp.deduct]]).
 ``` cpp
 template<class T1 = int, class T2> class B;   // error
-// U cannot be deduced or specified
-template<class... T, class... U> void f() { }
-template<class... T, class U> void g() { }
 ```
 A *template-parameter* shall not be given default arguments by two
 different declarations in the same scope.
@@ -294,11 +318,11 @@ expansion shall not expand a parameter pack declared in the same
 template <class... Types> class Tuple;                // Types is a template type parameter pack
                                                       // but not a pack expansion
 template <class T, int... Dims> struct multi_array;   // Dims is a non-type template parameter pack
                                                       // but not a pack expansion
 template<class... T> struct value_holder {
-  template<T... Values> apply { }; // Values is a non-type template parameter pack
                                                       // and a pack expansion
 };
 template<class... T, T... Values> struct static_array;// error: Values expands template type parameter
                                                       // pack T within the same template parameter list
 ```
@@ -346,13 +370,13 @@ For a *template-name* to be explicitly qualified by the template
 arguments, the name must be known to refer to a template.
 After name lookup ([[basic.lookup]]) finds that a name is a
 *template-name* or that an *operator-function-id* or a
 *literal-operator-id* refers to a set of overloaded functions any member
-of which is a function template if this is followed by a `<`, the `<` is
-always taken as the delimiter of a *template-argument-list* and never as
-the less-than operator. When parsing a *template-argument-list*, the
 first non-nested `>`[^2] is taken as the ending delimiter rather than a
 greater-than operator. Similarly, the first non-nested `>{>}` is treated
 as two consecutive but distinct `>` tokens, the first of which is taken
 as the end of the and completes the . The second `>` token produced by
 this replacement rule may terminate an enclosing construct or it may be
@@ -417,11 +441,11 @@ template <class T> struct B {
   template <class T2> struct C { };
 };
 // OK: T::template C names a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
-D<b<int> > db;
 ```
 A *simple-template-id* that names a class template specialization is a
 *class-name* (Clause  [[class]]).
@@ -602,22 +626,24 @@ shall be one of:
 - for a non-type *template-parameter* of integral or enumeration type, a
   converted constant expression ([[expr.const]]) of the type of the
   *template-parameter*; or
 - the name of a non-type *template-parameter*; or
 - a constant expression ([[expr.const]]) that designates the address of
- an object with static storage duration and external or internal
-  linkage or a function with external or internal linkage, including
-  function templates and function *template-id*s but excluding
   non-static class members, expressed (ignoring parentheses) as `&`
-  *id-expression*, except that the `&` may be omitted if the name refers
- to a function or array and shall be omitted if the corresponding
   *template-parameter* is a reference; or
 - a constant expression that evaluates to a null pointer value (
   [[conv.ptr]]); or
 - a constant expression that evaluates to a null member pointer value (
   [[conv.mem]]); or
-- a pointer to member expressed as described in  [[expr.unary.op]].
 A string literal ([[lex.string]]) does not satisfy the requirements of
 any of these categories and thus is not an acceptable
 *template-argument*.
@@ -671,18 +697,17 @@ the program is ill-formed.
 - for a non-type *template-parameter* of type pointer to object,
   qualification conversions ([[conv.qual]]) and the array-to-pointer
   conversion ([[conv.array]]) are applied; if the *template-argument*
   is of type `std::nullptr_t`, the null pointer conversion (
   [[conv.ptr]]) is applied. In particular, neither the null pointer
-  conversion for a zero-valued integral constant expression (
- [[conv.ptr]]) nor the derived-to-base conversion ([[conv.ptr]]) are
- applied. Although `0` is a valid *template-argument* for a non-type
- *template-parameter* of integral type, it is not a valid
-  *template-argument* for a non-type *template-parameter* of pointer
- type. However, both `(int*)0` and `nullptr` are valid
-  *template-argument*s for a non-type *template-parameter* of type
-  “pointer to int.”
 - For a non-type *template-parameter* of type reference to object, no
   conversions apply. The type referred to by the reference may be more
   cv-qualified than the (otherwise identical) type of the
   *template-argument*. The *template-parameter* is bound directly to the
   *template-argument*, which shall be an lvalue.
@@ -738,15 +763,15 @@ only primary class templates are considered when matching the template
 template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
 Any partial specializations ([[temp.class.spec]]) associated with the
-primary class template are considered when a specialization based on the
-template *template-parameter* is instantiated. If a specialization is
-not visible at the point of instantiation, and it would have been
-selected had it been visible, the program is ill-formed; no diagnostic
-is required.
 ``` cpp
 template<class T> class A {     // primary template
   int x;
 };
@@ -761,10 +786,26 @@ C<A> c;                         // V<int> within C<A> uses the primary template,
                                 // so c.y.x has type int
                                 // V<int*> within C<A> uses the partial specialization,
                                 // so c.z.x has type long
 ```
 ``` cpp
 template<class T> class A { /* ... */ };
 template<class T, class U = T> class B { /* ... */ };
 template <class ... Types> class C { /* ... */ };
@@ -778,22 +819,10 @@ X<C> xc;            // ill-formed: a template parameter pack does not match a te
 Y<A> ya;            // OK
 Y<B> yb;            // OK
 Y<C> yc;            // OK
 ```
-A *template-argument* matches a template *template-parameter* (call it
-`P`) when each of the template parameters in the
-*template-parameter-list* of the *template-argument*’s corresponding
-class template or alias template (call it `A`) matches the corresponding
-template parameter in the *template-parameter-list* of `P`. When `P`’s
-*template-parameter-list* contains a template parameter pack (
-[[temp.variadic]]), the template parameter pack will match zero or more
-template parameters or template parameter packs in the
-*template-parameter-list* of `A` with the same type and form as the
-template parameter pack in `P` (ignoring whether those template
-parameters are template parameter packs)
 ``` cpp
 template <class T> struct eval;
 template <template <class, class...> class TT, class T1, class... Rest>
 struct eval<TT<T1, Rest...>> { };
@@ -811,11 +840,11 @@ eval<D<int, 17>> eD;            // error: D does not match TT in partial special
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
 ## Type equivalence <a id="temp.type">[[temp.type]]</a>
-Two *template-id*s refer to the same class or function if
 - their *template-name*s, *operator-function-id*s, or
   *literal-operator-id*s refer to the same template and
 - their corresponding type *template-argument*s are the same type and
 - their corresponding non-type template arguments of integral or
@@ -878,15 +907,17 @@ 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 of
-function templates and default arguments of member functions of class
-templates are considered definitions; each default argument is a
-separate definition which is unrelated to the function template
-definition or to any other default arguments.
 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>
@@ -990,12 +1021,12 @@ 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 class member of a class template may be defined outside the class
-template definition in which it is declared. The class member must be
 defined before its first use that requires an instantiation (
 [[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
@@ -1006,18 +1037,27 @@ 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 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;
 ```
 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.
@@ -1061,27 +1101,27 @@ template<class T> struct string {
 template<class T> template<class T2> int string<T>::compare(const T2& s) {
 }
 ```
-A local class 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 normal (non-template) member function
-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);
 };
-template <> void A<int>::f(int) { }                     // non-template member
-template <> template <> void A<int>::f<>(int) { }       // template member
 int main() {
   A<char> ac;
   ac.f(1);          // non-template
   ac.f('c');        // template
@@ -1198,12 +1238,13 @@ the following contexts:
     *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]]); the pattern is a
-  *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
@@ -1213,10 +1254,15 @@ the following contexts:
 - In a *capture-list* ([[expr.prim.lambda]]); the pattern is a
   *capture*.
 - In a `sizeof...` expression ([[expr.sizeof]]); the pattern is an
   *identifier*.
 ``` 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
 }
@@ -1260,18 +1306,28 @@ template<class ... Args>
 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. 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...);
@@ -1287,25 +1343,25 @@ 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 an ordinary (non-template) function or class. For a friend
-function declaration that is not a template declaration:
 - if the name of the friend is a qualified or unqualified *template-id*,
   the friend declaration refers to a specialization of a function
-  template, otherwise
 - if the name of the friend is a *qualified-id* and a matching
   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
   template ([[temp.deduct.decl]]), otherwise,
-- the name shall be an *unqualified-id* that declares (or redeclares) an
- ordinary (non-template) function.
 ``` cpp
 template<class T> class task;
 template<class T> task<T>* preempt(task<T>*);
@@ -1323,11 +1379,11 @@ template<class T> class task {
 Here, each specialization of the `task` class template has the function
 `next_time` as a friend; because `process` does not have explicit
 *template-argument*s, each specialization of the `task` class template
 has an appropriately typed function `process` as a friend, and this
 friend is not a function template specialization; because the friend
-`preempt` has an explicit *template-argument* `<T>`, each specialization
 of the `task` class template has the appropriate specialization of the
 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,
@@ -1362,14 +1418,14 @@ class X {
 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.
-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
@@ -1537,10 +1593,12 @@ following restrictions apply:
   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 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.
@@ -1705,12 +1763,12 @@ family of sort functions might be declared like this:
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
 ```
 A function template can be overloaded with other function templates and
-with normal (non-template) functions. A normal 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>
@@ -1775,15 +1833,26 @@ 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.
 ``` 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
 ```
 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.
@@ -1850,18 +1919,19 @@ 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, that function template is
-considered to have a new first parameter inserted in its function
-parameter list. The new parameter is of type “reference to cv `A`,”
-where cv are the cv-qualifiers of the function template (if any) and `A`
-is the class of which the function template is a member. 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
@@ -2132,18 +2202,17 @@ template<class T> struct A {
   B b;              // OK, no typename required
 };
 ```
 Knowing which names are type names allows the syntax of every template
-definition to be checked. No diagnostic shall be issued for a template
-definition for which a valid specialization can be generated. If no
-valid specialization can be generated for a template definition, and
-that template is not instantiated, the template definition is
-ill-formed, no diagnostic required. If every valid specialization of a
-variadic template requires an empty template parameter pack, the
-template definition is ill-formed, no diagnostic required. If a type
-used in a non-dependent name is incomplete at the point at which a
 template is defined but is complete at the point at which an
 instantiation is done, and if the completeness of that type affects
 whether or not the program is well-formed or affects the semantics of
 the program, the program is ill-formed; no diagnostic is required. If a
 template is instantiated, errors will be diagnosed according to the
@@ -2234,13 +2303,14 @@ void h() {
                     // by two calls of f(E)
   g('a');           // will cause three calls of f(char)
 }
 ```
-For purposes of name lookup, default arguments of function templates and
-default arguments of member functions of class templates are considered
-definitions ([[temp.decls]]).
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name (Clause  [[class]]). The injected-class-name can be
@@ -2402,19 +2472,19 @@ and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
 names. Expressions may be *type-dependent* (on the type of a template
 parameter) or *value-dependent* (on the value of a non-type template
 parameter). In an expression of the form:
-where the *postfix-expression* is an *id-expression*, the
-*id-expression* denotes a *dependent name* if
 - any of the expressions in the *expression-list* is a pack expansion (
   [[temp.variadic]]),
 - any of the expressions in the *expression-list* is a type-dependent
   expression ([[temp.dep.expr]]), or
-- if the *unqualified-id* of the *id-expression* is a *template-id* in
- which any of the template arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
 operator also denotes a dependent name. Such names are unbound and are
 looked up at the point of the template instantiation ([[temp.point]])
 in both the context of the template definition and the context of the
@@ -2546,27 +2616,27 @@ template <class T1, class T2, int I> struct B {
 ```
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
-  member of the current instantiation or a non-dependent base class
-  thereof. This can only occur when looking up a name in a scope
-  enclosed by the definition of a class template.
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
-  member of the current instantiation or a non-dependent base class
-  thereof. if no such member is found, and the current instantiation has
-  any dependent base classes, then the *qualified-id* is a member of an
-  unknown specialization; see below.
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) for which the type of the object expression
   is the current instantiation, and the *id-expression*, when looked
-  up ([[basic.lookup.classref]]), refers to at least one member of the
-  current instantiation or a non-dependent base class thereof. if no
-  such member is found, and the current instantiation has any dependent
-  base classes, then the *id-expression* is a member of an unknown
-  specialization; see below.
 ``` cpp
 template <class T> class A {
   static const int i = 5;
   int n1[i];        // i refers to a member of the current instantiation
@@ -2578,25 +2648,30 @@ template <class T> class A {
 template <class T> int A<T>::f() {
   return i;         // i refers to a member of the current instantiation
 }
 ```
 A name is a *member of an unknown specialization* if it is
 - A *qualified-id* in which the *nested-name-specifier* names a
   dependent type that is not the current instantiation.
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
-  find any member of the current instantiation or a non-dependent base
-  class thereof.
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
-    name lookup of the *id-expression* does not find a member of the
-    current instantiation or a non-dependent base class thereof; or
   - the type of the object expression is dependent and is not the
     current instantiation.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
@@ -2634,12 +2709,12 @@ base class of the current instantiation.
 A type is dependent if it is
 - a template parameter,
 - a member of an unknown specialization,
-- a nested class or enumeration that is a member of the current
-  instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type constructed from any dependent type or whose size is
   specified by a constant expression that is value-dependent,
 - a *simple-template-id* in which either the template name is a template
@@ -2665,20 +2740,25 @@ dependent ([[temp.dep.type]]).
 An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
-or if it names a static data member of the current instantiation that
-has type “array of unknown bound of `T`” for some `T` (
-[[temp.static]]). Expressions of the following forms are type-dependent
-only if the type specified by the *type-id*, *simple-type-specifier* or
-*new-type-id* is dependent, even if any subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
 For the standard library macro `offsetof`, see  [[support.types]].
@@ -2698,16 +2778,21 @@ member access expression.
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, a constant expression is value-dependent if
 any subexpression is value-dependent.
-An *identifier* is value-dependent if it is:
-- a name declared with a dependent type,
-- the name of a non-type template parameter,
-- a constant with literal type and is initialized with an expression
- that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
@@ -2717,12 +2802,13 @@ Expressions of the following form are value-dependent if either the
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
 Expressions of the following form are value-dependent:
-An *id-expression* is value-dependent if it names a member of an unknown
-specialization.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
@@ -2790,10 +2876,21 @@ If a function template or member function of a class template is called
 in a way which uses the definition of a default argument of that
 function template or member function, the point of instantiation of the
 default argument is the point of instantiation of the function template
 or member function specialization.
 For a class template specialization, a class member template
 specialization, or a specialization for a class member of a class
 template, if the specialization is implicitly instantiated because it is
 referenced from within another template specialization, if the context
 from which the specialization is referenced depends on a template
@@ -2830,31 +2927,28 @@ units. If two different points of instantiation give a template
 specialization different meanings according to the one definition rule (
 [[basic.def.odr]]), the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
-For a function call that depends on a template parameter, the candidate
-functions are found using the usual lookup rules (
-[[basic.lookup.unqual]], [[basic.lookup.argdep]],
-[[basic.lookup.qual]]) except that:
 - For the part of the lookup using unqualified name lookup (
-  [[basic.lookup.unqual]]) or qualified name lookup (
-  [[basic.lookup.qual]]), only function declarations from the template
   definition context are found.
 - For the part of the lookup using associated namespaces (
   [[basic.lookup.argdep]]), only function declarations found in either
   the template definition context or the template instantiation context
   are found.
-If the function name is an *unqualified-id* and the call would be
-ill-formed or would find a better match had the lookup within the
-associated namespaces considered all the function declarations with
-external linkage introduced in those namespaces in all translation
-units, not just considering those declarations found in the template
-definition and template instantiation contexts, then the program has
-undefined behavior.
 ### Friend names declared within a class template <a id="temp.inject">[[temp.inject]]</a>
 Friend classes or functions can be declared within a class template.
 When a template is instantiated, the names of its friends are treated as
@@ -2970,18 +3064,19 @@ instantiated ([[temp.explicit]]) or explicitly specialized (
 [[temp.expl.spec]]), the class template specialization is implicitly
 instantiated when the specialization is referenced in a context that
 requires a completely-defined object type or when the completeness of
 the class type affects the semantics of the program. The implicit
 instantiation of a class template specialization causes the implicit
-instantiation of the declarations, but not of the definitions or default
-arguments, of the class member functions, member classes, scoped member
-enumerations, static data members and member templates; and it causes
-the implicit instantiation of the definitions of unscoped member
-enumerations and member anonymous unions. However, for the purpose of
-determining whether an instantiated redeclaration of a member is valid
-according to  [[class.mem]], a declaration that corresponds to a
-definition in the template is considered to be a definition.
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
@@ -3036,10 +3131,17 @@ void h() {
 ```
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
 A class template specialization is implicitly instantiated if the class
 type is used in a context that requires a completely-defined object type
 or if the completeness of the class type might affect the semantics of
 the program. In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
@@ -3099,28 +3201,28 @@ data members of that class to be implicitly instantiated.
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated ([[temp.over]]).
 An implementation shall not implicitly instantiate a function template,
-a member template, a non-virtual member function, a member class, or a
-static data member of a class template that does not require
-instantiation. It is unspecified whether or not an implementation
-implicitly instantiates a virtual member function of a class template if
-the virtual member function would not otherwise be instantiated. The use
-of a template specialization in a default argument shall not cause the
-template to be implicitly instantiated except that a class template may
-be instantiated where its complete type is needed to determine the
-correctness of the default argument. The use of a default argument in a
-function call causes specializations in the default argument to be
-implicitly instantiated.
-Implicitly instantiated class and function template specializations are
-placed in the namespace where the template is defined. Implicitly
-instantiated specializations for members of a class template are placed
-in the namespace where the enclosing class template is defined.
-Implicitly instantiated member templates are placed in the namespace
-where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
@@ -3147,13 +3249,16 @@ If a function template `f` is called in a way that requires a default
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
-function template `f` used at that point. This analysis is called
-*default argument instantiation*. The instantiated default argument is
-then used as the argument of `f`.
 Each default argument is instantiated independently.
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
@@ -3167,10 +3272,19 @@ void g(A a, A b, A c) {
   f(a, b);          // default argument z = zdef(T()) instantiated
   f(a);             // ill-formed; ydef is not declared
 }
 ```
 [[temp.point]] defines the point of instantiation of a template
 specialization.
 There is an implementation-defined quantity that specifies the limit on
 the total depth of recursive instantiations, which could involve more
@@ -3186,16 +3300,17 @@ template<class T> class X {
 };
 ```
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
-A class, a function or member template specialization can be explicitly
-instantiated from its template. A member function, member class or
-static data member of a class template can be explicitly instantiated
-from the member definition associated with its class template. An
-explicit instantiation of a function template or member function of a
-class template shall not use the `inline` or `constexpr` specifiers.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
@@ -3215,17 +3330,18 @@ a *template-name* or *operator-function-id*. The declaration may declare
 a *qualified-id*, in which case the *unqualified-id* of the
 *qualified-id* must be a *template-id*. If the explicit instantiation is
 for a member function, a member class or a static data member of a class
 template specialization, the name of the class template specialization
 in the *qualified-id* for the member name shall be a
-*simple-template-id*. An explicit instantiation shall appear in an
-enclosing namespace of its template. If the name declared in the
-explicit instantiation is an unqualified name, the explicit
-instantiation shall appear in the namespace where its template is
-declared or, if that namespace is inline ([[namespace.def]]), any
-namespace from its enclosing namespace set. Regarding qualified names in
-declarators, see  [[dcl.meaning]].
 ``` cpp
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
@@ -3237,35 +3353,36 @@ namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 ```
-A declaration of a function template, a member function or static data
-member of a class template, or a member function template of a class or
-class template shall precede an explicit instantiation of that entity. A
-definition of a class template, a member class of a class template, or a
-member class template of a class or class template shall precede an
-explicit instantiation of that entity unless the explicit instantiation
-is preceded by an explicit specialization of the entity with the same
-template arguments. If the *declaration* of the explicit instantiation
-names an implicitly-declared special member function (Clause
-[[special]]), the program is ill-formed.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
 an explicit instantiation definition the definition of a function
-template, a member function template, or a member function or static
-data member of a class template shall be present in every translation
-unit in which it is explicitly instantiated.
-An explicit instantiation of a class or function template specialization
-is placed in the namespace in which the template is defined. An explicit
-instantiation for a member of a class template is placed in the
-namespace where the enclosing class template is defined. An explicit
-instantiation for a member template is placed in the namespace where the
-enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
@@ -3296,28 +3413,31 @@ template void sort<>(Array<int>&);
 ```
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
-base classes) that has not been previously explicitly specialized in the
-translation unit containing the explicit instantiation, except as
-described below. In addition, it will typically be an explicit
-instantiation of certain implementation-dependent data about the class.
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
-Except for inline functions and class template specializations, explicit
-instantiation declarations have the effect of suppressing the implicit
-instantiation of the entity to which they refer. The intent is that an
-inline function that is the subject of an explicit instantiation
-declaration will still be implicitly instantiated when odr-used (
-[[basic.def.odr]]) so that the body can be considered for inlining, but
-that no out-of-line copy of the inline function would be generated in
-the translation unit.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
@@ -3353,10 +3473,11 @@ template int g<int>(int);       // OK even though &p isn't an int.
 An explicit specialization of any of the following:
 - function template
 - class template
 - member function of a class template
 - static data member of a class template
 - member class of a class template
 - member enumeration of a class template
 - member class template of a class or class template
@@ -3394,33 +3515,34 @@ enclosing namespace of the template, or, if the namespace is inline (
 [[namespace.def]]), any namespace from its enclosing namespace set. Such
 a declaration may also be a definition. If the declaration is not a
 definition, the specialization may be defined later (
 [[namespace.memdef]]).
-A declaration of a function template or class template being explicitly
-specialized shall precede the declaration of the explicit
-specialization. A declaration, but not a definition of the template is
-required. The definition of a class or class template shall precede the
-declaration of an explicit specialization for a member template of the
-class or class template.
 ``` cpp
 template<> class X<int> { /* ... */ };          // error: X not a template
 template<class T> class X;
 template<> class X<char*> { /* ... */ };        // OK: X is a template
 ```
 A member function, a member function template, a member class, a member
-enumeration, a member class template, or a static data member of a class
-template may be explicitly specialized for a class specialization that
-is implicitly instantiated; in this case, the definition of the class
-template shall precede the explicit specialization for the member of the
-class template. If such an explicit specialization for the member of a
-class template names an implicitly-declared special member function
-(Clause  [[special]]), the program is ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
@@ -3512,31 +3634,33 @@ template<class T> struct A {
 };
 template<> enum A<int>::E : int { eint };         // OK
 template<> enum class A<int>::S : int { sint };   // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
-template<> enum A<char>::E : int { echar };       // ill-formed, A<char>::E was instantiated
                                                    // when A<char> was instantiated
-template<> enum class A<char>::S : int { schar }; // OK
 ```
 The placement of explicit specialization declarations for function
-templates, class templates, member functions of class templates, static
-data members of class templates, member classes of class templates,
-member enumerations of class templates, member class templates of class
-templates, member function templates of class templates, member
 functions of member templates of class templates, member functions of
-member templates of non-template classes, member function templates of
-member classes of class templates, etc., and the placement of partial
-specialization declarations of class templates, member class templates
-of non-template classes, member class templates of class templates,
-etc., can affect whether a program is well-formed according to the
-relative positioning of the explicit specialization declarations and
-their points of instantiation in the translation unit as specified above
-and below. When writing a specialization, be careful about its location;
-or to make it compile will be such a trial as to kindle its
-self-immolation.
 A template explicit specialization is in the scope of the namespace in
 which the template was defined.
 ``` cpp
@@ -3549,11 +3673,13 @@ namespace N {
   template<> class Y<double>;                   // forward declare intent to
                                                 // specialize for double
 }
 template<> class N::Y<double> { /* ... */ };      // OK: specialization
-                                                // in same namespace
 ```
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes (
@@ -3594,13 +3720,14 @@ template<class T> inline T g(T) { /* ... */ }
 template<> inline void f<>(int) { /* ... */ }   // OK: inline
 template<> int g<>(int) { /* ... */ }           // OK: not inline
 ```
-An explicit specialization of a static data member of a template is a
-definition if the declaration includes an initializer; otherwise, it is
-a declaration. The definition of a static data member of a template that
 requires default initialization must use a *braced-init-list*:
 ``` cpp
 template<> X Q<int>::x;         // declaration
 template<> X Q<int>::x ();      // error: declares a function
@@ -3683,12 +3810,13 @@ template <> template <> template<class T>
 template <class Y> template <>
   void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
-A specialization of a member function template or member class template
-of a non-specialized class template is itself a template.
 An explicit specialization declaration shall not be a friend
 declaration.
 Default function arguments shall not be specified in a declaration or a
@@ -3794,13 +3922,13 @@ void h() {
                                 // int (*)(bool), Z is deduced to an empty sequence
 }
 ```
 An empty template argument list can be used to indicate that a given use
-refers to a specialization of a function template even when a normal
-(i.e., non-template) function is visible that would otherwise be used.
-For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 int k = f(1);                   // uses #2
@@ -3969,12 +4097,15 @@ int main() {
 `f<int>(1)` and `f<const int>(1)` call distinct functions even though
 both of the functions called have the same function type.
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
-argument has not been deduced, its default template argument, if any, is
-used.
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
@@ -4007,24 +4138,40 @@ The substitution occurs in all types and expressions that are used in
 the function type and in template parameter declarations. The
 expressions include not only constant expressions such as those that
 appear in array bounds or as nontype template arguments but also general
 expressions (i.e., non-constant expressions) inside `sizeof`,
 `decltype`, and other contexts that allow non-constant expressions. The
-equivalent substitution in exception specifications is done only when
-the function is instantiated, at which point a program is ill-formed if
-the substitution results in an invalid type or expression.
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
-ill-formed if written using the substituted arguments. Access checking
-is done as part of the substitution process. Only invalid types and
-expressions in the immediate context of the function type and its
-template parameter types can result in a deduction failure. The
-evaluation of the substituted types and expressions can result in side
-effects such as the instantiation of class template specializations
-and/or function template specializations, the generation of
-implicitly-defined functions, etc. Such side effects are not in the
 “immediate context” and can result in the program being ill-formed.
 ``` cpp
 struct X { };
 struct Y {
@@ -4154,22 +4301,26 @@ g({1,2,3});                 // error: no argument deduced for T
 For a function parameter pack that occurs at the end of the
 *parameter-declaration-list*, the type `A` of each remaining argument of
 the call is compared with the type `P` of the *declarator-id* of the
 function parameter pack. Each comparison deduces template arguments for
 subsequent positions in the template parameter packs expanded by the
-function parameter pack. For a function parameter pack that does not
-occur at the end of the *parameter-declaration-list*, the type of the
-parameter pack is a non-deduced context.
 ``` cpp
 template<class ... Types> void f(Types& ...);
 template<class T1, class ... Types> void g(T1, Types ...);
 void h(int x, float& y) {
   const int z = x;
   f(x, y, z);                  // Types is deduced to int, float, const int
   g(x, y, z);                  // T1 is deduced to int; Types is deduced to float, int
 }
 ```
 If `P` is not a reference type:
@@ -4275,17 +4426,22 @@ Template arguments can be deduced from the type specified when taking
 the address of an overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
 `P` and `A`, and the deduction is done as described in
 [[temp.deduct.type]].
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
 Template argument deduction is done by comparing the return type of the
-conversion function template (call it `P`; see  [[dcl.init]],
-[[over.match.conv]], and [[over.match.ref]] for the determination of
-that type) with the type that is required as the result of the
-conversion (call it `A`) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
 transformations of `P` in the remainder of this section.
@@ -4355,11 +4511,11 @@ argument template and template-1 as the parameter template.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
   parameter types for which the function call has arguments.[^7]
-- In the context of a call to a conversion operator, the return types of
   the conversion function templates are used.
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
@@ -4503,10 +4659,11 @@ specified, template argument deduction fails.
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
@@ -4526,11 +4683,11 @@ The non-deduced contexts are:
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
 - A function parameter pack that does not occur at the end of the
-  *parameter-declaration-clause*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
 non-deduced types. If a type is specified as `A<T>::B<T2>`, both `T` and
@@ -4798,17 +4955,14 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 // A<int>::X
 // i is explicitly specified to be 77, b.ym must be convertible
 // to B<77>::Y
 ```
-If, in the declaration of a function template with a non-type
-*template-parameter,* the non-type *template-parameter* is used in an
-expression in the function parameter-list and, if the corresponding
-*template-argument* is deduced, the *template-argument* type shall match
-the type of the *template-parameter* exactly, except that a
-*template-argument* deduced from an array bound may be of any integral
-type.[^8]
 ``` cpp
 template<int i> class A { /* ... */ };
 template<short s> void f(A<s>);
 void k1() {
@@ -5036,10 +5190,11 @@ explicitly generated, is present in some translation unit.
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [except.spec]: except.md#except.spec
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda]: expr.md#expr.prim.lambda

 The `>` token following the of a may be the product of replacing a
 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 The *declaration* in a *template-declaration* shall
+- declare or define a function, a class, or a variable, or
 - define a member function, a member class, a member enumeration, or a
   static data member of a class template or of a class nested within a
   class template, or
 - define a member template of a class or class template, or
 - be an *alias-declaration*.
 A *template-declaration* is a *declaration*. A *template-declaration* is
+also a definition if its *declaration* defines a function, a class, a
+variable, or a static data member. A declaration introduced by a
+template declaration of a variable is a *variable template*. A variable
+template at class scope is a *static data member template*.
+``` cpp
+template<class T>
+  constexpr T pi = T(3.1415926535897932385L);
+template<class T>
+T circular_area(T r) {
+  return pi<T> * r * r;
+}
+struct matrix_constants {
+  template<class T>
+   using pauli = hermitian_matrix<T, 2>;
+  template<class T>
+   constexpr pauli<T> sigma1 = { { 0, 1 }, { 1, 0 } };
+  template<class T>
+   constexpr pauli<T> sigma2 = { { 0, -1i }, { 1i, 0 } };
+  template<class T>
+   constexpr pauli<T> sigma3 = { { 1, 0 }, { 0, -1 } };
+};
+```
 A *template-declaration* can appear only as a namespace scope or class
 scope declaration. In a function template declaration, the last
 component of the *declarator-id* shall not be a *template-id*. That last
 component may be an *identifier*, an *operator-function-id*, a
 A class template shall not have the same name as any other template,
 class, function, variable, enumeration, enumerator, namespace, or type
 in the same scope ([[basic.scope]]), except as specified in (
 [[temp.class.spec]]). Except that a function template can be overloaded
+either by non-template functions ([[dcl.fct]]) with the same name or by
+other function templates with the same name ([[temp.over]]), a template
+name declared in namespace scope or in class scope shall be unique in
+that scope.
+A function template, member function of a class template, variable
+template, or static data member of a class template shall be defined in
+every translation unit in which it is implicitly instantiated (
+[[temp.inst]]) unless the corresponding specialization is explicitly
+instantiated ([[temp.explicit]]) in some translation unit; no
+diagnostic is required.
 ## Template parameters <a id="temp.param">[[temp.param]]</a>
 The syntax for *template-parameter*s is:
 There is no semantic difference between `class` and `typename` in a
 *template-parameter*. `typename` followed by an *unqualified-id* names a
 template type parameter. `typename` followed by a *qualified-id* denotes
 the type in a non-type [^1] *parameter-declaration*. A storage class
+shall not be specified in a *template-parameter* declaration. Types
+shall not be defined in a *template-parameter* declaration. A template
 parameter may be a class template. For example,
 ``` cpp
 template<class T> class myarray { /* ... */ };
 either have a default *template-argument* supplied or be a template
 parameter pack. If a *template-parameter* of a primary class template or
 alias template is a template parameter pack, it shall be the last
 *template-parameter*. A template parameter pack of a function template
 shall not be followed by another template parameter unless that template
+parameter can be deduced from the *parameter-type-list* of the function
+template or has a default argument ([[temp.deduct]]).
 ``` cpp
 template<class T1 = int, class T2> class B;   // error
+// U can be neither deduced from the parameter-type-list nor specified
+template<class... T, class... U> void f() { } // error
+template<class... T, class U> void g() { }    // error
 ```
 A *template-parameter* shall not be given default arguments by two
 different declarations in the same scope.
 template <class... Types> class Tuple;                // Types is a template type parameter pack
                                                       // but not a pack expansion
 template <class T, int... Dims> struct multi_array;   // Dims is a non-type template parameter pack
                                                       // but not a pack expansion
 template<class... T> struct value_holder {
+  template<T... Values> struct apply { }; // Values is a non-type template parameter pack
                                                       // and a pack expansion
 };
 template<class... T, T... Values> struct static_array;// error: Values expands template type parameter
                                                       // pack T within the same template parameter list
 ```
 arguments, the name must be known to refer to a template.
 After name lookup ([[basic.lookup]]) finds that a name is a
 *template-name* or that an *operator-function-id* or a
 *literal-operator-id* refers to a set of overloaded functions any member
+of which is a function template, if this is followed by a `<`, the `<`
+is always taken as the delimiter of a *template-argument-list* and never
+as the less-than operator. When parsing a *template-argument-list*, the
 first non-nested `>`[^2] is taken as the ending delimiter rather than a
 greater-than operator. Similarly, the first non-nested `>{>}` is treated
 as two consecutive but distinct `>` tokens, the first of which is taken
 as the end of the and completes the . The second `>` token produced by
 this replacement rule may terminate an enclosing construct or it may be
   template <class T2> struct C { };
 };
 // OK: T::template C names a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
+D<B<int> > db;
 ```
 A *simple-template-id* that names a class template specialization is a
 *class-name* (Clause  [[class]]).
 - for a non-type *template-parameter* of integral or enumeration type, a
   converted constant expression ([[expr.const]]) of the type of the
   *template-parameter*; or
 - the name of a non-type *template-parameter*; or
 - a constant expression ([[expr.const]]) that designates the address of
+ a complete object with static storage duration and external or
+ internal linkage or a function with external or internal linkage,
+ including function templates and function *template-id*s but excluding
   non-static class members, expressed (ignoring parentheses) as `&`
+  *id-expression*, where the *id-expression* is the name of an object or
+  function, except that the `&` may be omitted if the name refers to a
+  function or array and shall be omitted if the corresponding
   *template-parameter* is a reference; or
 - a constant expression that evaluates to a null pointer value (
   [[conv.ptr]]); or
 - a constant expression that evaluates to a null member pointer value (
   [[conv.mem]]); or
+- a pointer to member expressed as described in  [[expr.unary.op]]; or
+- a constant expression of type `std::nullptr_t`.
 A string literal ([[lex.string]]) does not satisfy the requirements of
 any of these categories and thus is not an acceptable
 *template-argument*.
 - for a non-type *template-parameter* of type pointer to object,
   qualification conversions ([[conv.qual]]) and the array-to-pointer
   conversion ([[conv.array]]) are applied; if the *template-argument*
   is of type `std::nullptr_t`, the null pointer conversion (
   [[conv.ptr]]) is applied. In particular, neither the null pointer
+  conversion for a zero-valued integer literal ([[conv.ptr]]) nor the
+  derived-to-base conversion ([[conv.ptr]]) are applied. Although `0`
+  is a valid *template-argument* for a non-type *template-parameter* of
+  integral type, it is not a valid *template-argument* for a non-type
+  *template-parameter* of pointer type. However, both `(int*)0` and
+  `nullptr` are valid *template-argument*s for a non-type
+  *template-parameter* of type “pointer to int.”
 - For a non-type *template-parameter* of type reference to object, no
   conversions apply. The type referred to by the reference may be more
   cv-qualified than the (otherwise identical) type of the
   *template-argument*. The *template-parameter* is bound directly to the
   *template-argument*, which shall be an lvalue.
 template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
 Any partial specializations ([[temp.class.spec]]) associated with the
+primary class template or primary variable template are considered when
+a specialization based on the template *template-parameter* is
+instantiated. If a specialization is not visible at the point of
+instantiation, and it would have been selected had it been visible, the
+program is ill-formed; no diagnostic is required.
 ``` cpp
 template<class T> class A {     // primary template
   int x;
 };
                                 // so c.y.x has type int
                                 // V<int*> within C<A> uses the partial specialization,
                                 // so c.z.x has type long
 ```
+A *template-argument* matches a template *template-parameter* (call it
+`P`) when each of the template parameters in the
+*template-parameter-list* of the *template-argument*’s corresponding
+class template or alias template (call it `A`) matches the corresponding
+template parameter in the *template-parameter-list* of `P`. Two template
+parameters match if they are of the same kind (type, non-type,
+template), for non-type *template-parameter*s, their types are
+equivalent ([[temp.over.link]]), and for template
+*template-parameter*s, each of their corresponding *template-parameter*s
+matches, recursively. When `P`’s *template-parameter-list* contains a
+template parameter pack ([[temp.variadic]]), the template parameter
+pack will match zero or more template parameters or template parameter
+packs in the *template-parameter-list* of `A` with the same type and
+form as the template parameter pack in `P` (ignoring whether those
+template parameters are template parameter packs).
 ``` cpp
 template<class T> class A { /* ... */ };
 template<class T, class U = T> class B { /* ... */ };
 template <class ... Types> class C { /* ... */ };
 Y<A> ya;            // OK
 Y<B> yb;            // OK
 Y<C> yc;            // OK
 ```
 ``` cpp
 template <class T> struct eval;
 template <template <class, class...> class TT, class T1, class... Rest>
 struct eval<TT<T1, Rest...>> { };
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
 ## Type equivalence <a id="temp.type">[[temp.type]]</a>
+Two *template-id*s refer to the same class, function, or variable if
 - their *template-name*s, *operator-function-id*s, or
   *literal-operator-id*s refer to the same template and
 - their corresponding type *template-argument*s are the same type and
 - their corresponding non-type template arguments of integral or
 ```
 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>
 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 {
 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;
+struct limits {
+  template<class T>
+    static const T min;           // declaration
+};
+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.
 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);
 };
+template <> void A<int>::f(int) { }                     // non-template member function
+template <> template <> void A<int>::f<>(int) { }       // member function template specialization
 int main() {
   A<char> ac;
   ac.f(1);          // non-template
   ac.f('c');        // template
     *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 a *dynamic-exception-specification* ([[except.spec]]); the pattern
   is a *type-id*.
 - In an *attribute-list* ([[dcl.attr.grammar]]); the pattern is an
 - 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
 }
 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...);
 ### Friends <a id="temp.friend">[[temp.friend]]</a>
 A friend of a class or class template can be a function template or
 class template, a specialization of a function template or class
+template, or a non-template function or class. For a friend function
+declaration that is not a template declaration:
 - if the name of the friend is a qualified or unqualified *template-id*,
   the friend declaration refers to a specialization of a function
+  template, otherwise,
 - if the name of the friend is a *qualified-id* and a matching
   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
   template ([[temp.deduct.decl]]), otherwise,
+- the name shall be an *unqualified-id* that declares (or redeclares) a
+  non-template function.
 ``` cpp
 template<class T> class task;
 template<class T> task<T>* preempt(task<T>*);
 Here, each specialization of the `task` class template has the function
 `next_time` as a friend; because `process` does not have explicit
 *template-argument*s, each specialization of the `task` class template
 has an appropriately typed function `process` as a friend, and this
 friend is not a function template specialization; because the friend
+`preempt` has an explicit *template-argument* `T`, each specialization
 of the `task` class template has the appropriate specialization of the
 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,
 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
   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
   argument is a pack expansion ([[temp.variadic]]), it shall be the
   last argument in the template argument list.
 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]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 *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();
+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()
 ```
 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.
 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
   B b;              // OK, no typename required
 };
 ```
 Knowing which names are type names allows the syntax of every template
+to be checked. No diagnostic shall be issued for a template for which a
+valid specialization can be generated. If no valid specialization can be
+generated for a template, and that template is not instantiated, the
+template is ill-formed, no diagnostic required. If every valid
+specialization of a variadic template requires an empty template
+parameter pack, the template is ill-formed, no diagnostic required. If a
+type used in a non-dependent name is incomplete at the point at which a
 template is defined but is complete at the point at which an
 instantiation is done, and if the completeness of that type affects
 whether or not the program is well-formed or affects the semantics of
 the program, the program is ill-formed; no diagnostic is required. If a
 template is instantiated, errors will be diagnosed according to the
                     // by two calls of f(E)
   g('a');           // will cause three calls of f(char)
 }
 ```
+For purposes of name lookup, 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 ([[temp.decls]]).
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name (Clause  [[class]]). The injected-class-name can be
 arguments) and this determines the context for name lookup for certain
 names. Expressions may be *type-dependent* (on the type of a template
 parameter) or *value-dependent* (on the value of a non-type template
 parameter). In an expression of the form:
+where the *postfix-expression* is an *unqualified-id*, the
+*unqualified-id* denotes a *dependent name* if
 - any of the expressions in the *expression-list* is a pack expansion (
   [[temp.variadic]]),
 - any of the expressions in the *expression-list* is a type-dependent
   expression ([[temp.dep.expr]]), or
+- if the *unqualified-id* is a *template-id* in which any of the
+  template arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
 operator also denotes a dependent name. Such names are unbound and are
 looked up at the point of the template instantiation ([[temp.point]])
 in both the context of the template definition and the context of the
 ```
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
+  member of a class that is the current instantiation or a non-dependent
+ base class thereof. This can only occur when looking up a name in a
+ scope enclosed by the definition of a class template.
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
+  member of a class that is the current instantiation or a non-dependent
+ base class thereof. if no such member is found, and the current
+ instantiation has any dependent base classes, then the *qualified-id*
+ is a member of an unknown specialization; see below.
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) for which the type of the object expression
   is the current instantiation, and the *id-expression*, when looked
+  up ([[basic.lookup.classref]]), refers to at least one member of a
+ class that is the current instantiation or a non-dependent base class
+ thereof. if no such member is found, and the current instantiation has
+ any dependent base classes, then the *id-expression* is a member of an
+ unknown specialization; see below.
 ``` cpp
 template <class T> class A {
   static const int i = 5;
   int n1[i];        // i refers to a member of the current instantiation
 template <class T> int A<T>::f() {
   return i;         // i refers to a member of the current instantiation
 }
 ```
+A name is a *dependent member of the current instantiation* if it is a
+member of the current instantiation that, when looked up, refers to at
+least one member of a class that is the current instantiation.
 A name is a *member of an unknown specialization* if it is
 - A *qualified-id* in which the *nested-name-specifier* names a
   dependent type that is not the current instantiation.
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
+  find any member of a class that is the current instantiation or a
+ non-dependent base class thereof.
 - An *id-expression* denoting the member in a class member access
   expression ([[expr.ref]]) in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
+    name lookup of the *id-expression* does not find a member of a class
+ that is the current instantiation or a non-dependent base class
+    thereof; or
   - the type of the object expression is dependent and is not the
     current instantiation.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
 A type is dependent if it is
 - a template parameter,
 - a member of an unknown specialization,
+- a nested class or enumeration that is a dependent member of the
+ current instantiation,
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type constructed from any dependent type or whose size is
   specified by a constant expression that is value-dependent,
 - a *simple-template-id* in which either the template name is a template
 An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
+- an *identifier* associated by name lookup with one or more
+  declarations of member functions of the current instantiation declared
+  with a return type that contains a placeholder type (
+  [[dcl.spec.auto]]),
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
+or if it names a dependent member of the current instantiation that is a
+static data member of type “array of unknown bound of `T`” for some
+`T` ([[temp.static]]). Expressions of the following forms are
+type-dependent only if the type specified by the *type-id*,
+*simple-type-specifier* or *new-type-id* is dependent, even if any
+subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
 For the standard library macro `offsetof`, see  [[support.types]].
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, a constant expression is value-dependent if
 any subexpression is value-dependent.
+An *id-expression* is value-dependent if:
+- it is a name declared with a dependent type,
+- it is the name of a non-type template parameter,
+- it names a member of an unknown specialization,
+- it names a static data member that is a dependent member of the
+  current instantiation and is not initialized in a *member-declarator*,
+- it names a static member function that is a dependent member of the
+  current instantiation, or
+- it is a constant with literal type and is initialized with an
+  expression that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
 Expressions of the following form are value-dependent:
+An expression of the form `&`*qualified-id* where the *qualified-id*
+names a dependent member of the current instantiation is
+value-dependent.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
 in a way which uses the definition of a default argument of that
 function template or member function, the point of instantiation of the
 default argument is the point of instantiation of the function template
 or member function specialization.
+For an *exception-specification* of a function template specialization
+or specialization of a member function of a class template, if the
+*exception-specification* is implicitly instantiated because it is
+needed by another template specialization and the context that requires
+it depends on a template parameter, the point of instantiation of the
+*exception-specification* is the point of instantiation of the
+specialization that requires it. Otherwise, the point of instantiation
+for such an *exception-specification* immediately follows the namespace
+scope declaration or definition that requires the
+*exception-specification*.
 For a class template specialization, a class member template
 specialization, or a specialization for a class member of a class
 template, if the specialization is implicitly instantiated because it is
 referenced from within another template specialization, if the context
 from which the specialization is referenced depends on a template
 specialization different meanings according to the one definition rule (
 [[basic.def.odr]]), the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
+For a function call where the *postfix-expression* is a dependent name,
+the candidate functions are found using the usual lookup rules (
+[[basic.lookup.unqual]], [[basic.lookup.argdep]]) except that:
 - For the part of the lookup using unqualified name lookup (
+  [[basic.lookup.unqual]]), only function declarations from the template
   definition context are found.
 - For the part of the lookup using associated namespaces (
   [[basic.lookup.argdep]]), only function declarations found in either
   the template definition context or the template instantiation context
   are found.
+If the call would be ill-formed or would find a better match had the
+lookup within the associated namespaces considered all the function
+declarations with external linkage introduced in those namespaces in all
+translation units, not just considering those declarations found in the
+template definition and template instantiation contexts, then the
+program has undefined behavior.
 ### Friend names declared within a class template <a id="temp.inject">[[temp.inject]]</a>
 Friend classes or functions can be declared within a class template.
 When a template is instantiated, the names of its friends are treated as
 [[temp.expl.spec]]), the class template specialization is implicitly
 instantiated when the specialization is referenced in a context that
 requires a completely-defined object type or when the completeness of
 the class type affects the semantics of the program. The implicit
 instantiation of a class template specialization causes the implicit
+instantiation of the declarations, but not of the definitions, default
+arguments, or *exception-specification*s of the class member functions,
+member classes, scoped member enumerations, static data members and
+member templates; and it causes the implicit instantiation of the
+definitions of unscoped member enumerations and member anonymous unions.
+However, for the purpose of determining whether an instantiated
+redeclaration of a member is valid according to  [[class.mem]], a
+declaration that corresponds to a definition in the template is
+considered to be a definition.
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
 ```
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
+Unless a variable template specialization has been explicitly
+instantiated or explicitly specialized, the variable template
+specialization is implicitly instantiated when the specialization is
+used. A default template argument for a variable template is implicitly
+instantiated when the variable template is referenced in a context that
+requires the value of the default argument.
 A class template specialization is implicitly instantiated if the class
 type is used in a context that requires a completely-defined object type
 or if the completeness of the class type might affect the semantics of
 the program. In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated ([[temp.over]]).
 An implementation shall not implicitly instantiate a function template,
+a variable template, a member template, a non-virtual member function, a
+member class, or a static data member of a class template that does not
+require instantiation. It is unspecified whether or not an
+implementation implicitly instantiates a virtual member function of a
+class template if the virtual member function would not otherwise be
+instantiated. The use of a template specialization in a default argument
+shall not cause the template to be implicitly instantiated except that a
+class template may be instantiated where its complete type is needed to
+determine the correctness of the default argument. The use of a default
+argument in a function call causes specializations in the default
+argument to be implicitly instantiated.
+Implicitly instantiated class, function, and variable template
+specializations are placed in the namespace where the template is
+defined. Implicitly instantiated specializations for members of a class
+template are placed in the namespace where the enclosing class template
+is defined. Implicitly instantiated member templates are placed in the
+namespace where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
+function template `f` used at that point, except that the scope in which
+a closure type is declared ([[expr.prim.lambda]]) – and therefore its
+associated namespaces – remain as determined from the context of the
+definition for the default argument. This analysis is called *default
+argument instantiation*. The instantiated default argument is then used
+as the argument of `f`.
 Each default argument is instantiated independently.
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
   f(a, b);          // default argument z = zdef(T()) instantiated
   f(a);             // ill-formed; ydef is not declared
 }
 ```
+The *exception-specification* of a function template specialization is
+not instantiated along with the function declaration; it is instantiated
+when needed ([[except.spec]]). If such an *exception-specification* is
+needed but has not yet been instantiated, the dependent names are looked
+up, the semantics constraints are checked, and the instantiation of any
+template used in the *exception-specification* is done as if it were
+being done as part of instantiating the declaration of the
+specialization at that point.
 [[temp.point]] defines the point of instantiation of a template
 specialization.
 There is an implementation-defined quantity that specifies the limit on
 the total depth of recursive instantiations, which could involve more
 };
 ```
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
+A class, function, variable, or member template specialization can be
+explicitly instantiated from its template. A member function, member
+class or static data member of a class template can be explicitly
+instantiated from the member definition associated with its class
+template. An explicit instantiation of a function template or member
+function of a class template shall not use the `inline` or `constexpr`
+specifiers.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
 a *qualified-id*, in which case the *unqualified-id* of the
 *qualified-id* must be a *template-id*. If the explicit instantiation is
 for a member function, a member class or a static data member of a class
 template specialization, the name of the class template specialization
 in the *qualified-id* for the member name shall be a
+*simple-template-id*. If the explicit instantiation is for a variable,
+the *unqualified-id* in the declaration shall be a *template-id*. An
+explicit instantiation shall appear in an enclosing namespace of its
+template. If the name declared in the explicit instantiation is an
+unqualified name, the explicit instantiation shall appear in the
+namespace where its template is declared or, if that namespace is
+inline ([[namespace.def]]), any namespace from its enclosing namespace
+set. Regarding qualified names in declarators, see  [[dcl.meaning]].
 ``` cpp
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 ```
+A declaration of a function template, a variable template, a member
+function or static data member of a class template, or a member function
+template of a class or class template shall precede an explicit
+instantiation of that entity. A definition of a class template, a member
+class of a class template, or a member class template of a class or
+class template shall precede an explicit instantiation of that entity
+unless the explicit instantiation is preceded by an explicit
+specialization of the entity with the same template arguments. If the
+*declaration* of the explicit instantiation names an implicitly-declared
+special member function (Clause  [[special]]), the program is
+ill-formed.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
 an explicit instantiation definition the definition of a function
+template, a variable template, a member function template, or a member
+function or static data member of a class template shall be present in
+every translation unit in which it is explicitly instantiated.
+An explicit instantiation of a class, function template, or variable
+template specialization is placed in the namespace in which the template
+is defined. An explicit instantiation for a member of a class template
+is placed in the namespace where the enclosing class template is
+defined. An explicit instantiation for a member template is placed in
+the namespace where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
 ```
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
+base classes and members that are templates) that has not been
+previously explicitly specialized in the translation unit containing the
+explicit instantiation, except as described below. In addition, it will
+typically be an explicit instantiation of certain
+implementation-dependent data about the class.
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
+Except for inline functions, declarations with types deduced from their
+initializer or return value ([[dcl.spec.auto]]), `const` variables of
+literal types, variables of reference types, and class template
+specializations, explicit instantiation declarations have the effect of
+suppressing the implicit instantiation of the entity to which they
+refer. The intent is that an inline function that is the subject of an
+explicit instantiation declaration will still be implicitly instantiated
+when odr-used ([[basic.def.odr]]) so that the body can be considered
+for inlining, but that no out-of-line copy of the inline function would
+be generated in the translation unit.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
 An explicit specialization of any of the following:
 - function template
 - class template
+- variable template
 - member function of a class template
 - static data member of a class template
 - member class of a class template
 - member enumeration of a class template
 - member class template of a class or class template
 [[namespace.def]]), any namespace from its enclosing namespace set. Such
 a declaration may also be a definition. If the declaration is not a
 definition, the specialization may be defined later (
 [[namespace.memdef]]).
+A declaration of a function template, class template, or variable
+template being explicitly specialized shall precede the declaration of
+the explicit specialization. A declaration, but not a definition of the
+template is required. The definition of a class or class template shall
+precede the declaration of an explicit specialization for a member
+template of the class or class template.
 ``` cpp
 template<> class X<int> { /* ... */ };          // error: X not a template
 template<class T> class X;
 template<> class X<char*> { /* ... */ };        // OK: X is a template
 ```
 A member function, a member function template, a member class, a member
+enumeration, a member class template, a static data member, or a static
+data member template of a class template may be explicitly specialized
+for a class specialization that is implicitly instantiated; in this
+case, the definition of the class template shall precede the explicit
+specialization for the member of the class template. If such an explicit
+specialization for the member of a class template names an
+implicitly-declared special member function (Clause  [[special]]), the
+program is ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
 };
 template<> enum A<int>::E : int { eint };         // OK
 template<> enum class A<int>::S : int { sint };   // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
+template<> enum A<char>::E : char { echar };       // ill-formed, A<char>::E was instantiated
                                                    // when A<char> was instantiated
+template<> enum class A<char>::S : char { schar }; // OK
 ```
 The placement of explicit specialization declarations for function
+templates, class templates, variable templates, member functions of
+class templates, static data members of class templates, member classes
+of class templates, member enumerations of class templates, member class
+templates of class templates, member function templates of class
+templates, static data member templates of class templates, member
 functions of member templates of class templates, member functions of
+member templates of non-template classes, static data member templates
+of non-template classes, member function templates of member classes of
+class templates, etc., and the placement of partial specialization
+declarations of class templates, variable templates, member class
+templates of non-template classes, static data member templates of
+non-template classes, member class templates of class templates, etc.,
+can affect whether a program is well-formed according to the relative
+positioning of the explicit specialization declarations and their points
+of instantiation in the translation unit as specified above and below.
+When writing a specialization, be careful about its location; or to make
+it compile will be such a trial as to kindle its self-immolation.
 A template explicit specialization is in the scope of the namespace in
 which the template was defined.
 ``` cpp
   template<> class Y<double>;                   // forward declare intent to
                                                 // specialize for double
 }
 template<> class N::Y<double> { /* ... */ };      // OK: specialization
+                                                // in enclosing namespace
+template<> class N::Y<short> { /* ... */ };       // OK: specialization
+                                                // in enclosing namespace
 ```
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes (
 template<> inline void f<>(int) { /* ... */ }   // OK: inline
 template<> int g<>(int) { /* ... */ }           // OK: not inline
 ```
+An explicit specialization of a static data member of a template or an
+explicit specialization of a static data member template is a definition
+if the declaration includes an initializer; otherwise, it is a
+declaration. The definition of a static data member of a template that
 requires default initialization must use a *braced-init-list*:
 ``` cpp
 template<> X Q<int>::x;         // declaration
 template<> X Q<int>::x ();      // error: declares a function
 template <class Y> template <>
   void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
+A specialization of a member function template, member class template,
+or static data member template of a non-specialized class template is
+itself a template.
 An explicit specialization declaration shall not be a friend
 declaration.
 Default function arguments shall not be specified in a declaration or a
                                 // int (*)(bool), Z is deduced to an empty sequence
 }
 ```
 An empty template argument list can be used to indicate that a given use
+refers to a specialization of a function template even when a
+non-template function ([[dcl.fct]]) is visible that would otherwise be
+used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 int k = f(1);                   // uses #2
 `f<int>(1)` and `f<const int>(1)` call distinct functions even though
 both of the functions called have the same function type.
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
+argument has not been deduced and its corresponding template parameter
+has a default argument, the template argument is determined by
+substituting the template arguments determined for preceding template
+parameters into the default argument. If the substitution results in an
+invalid type, as described above, type deduction fails.
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
 the function type and in template parameter declarations. The
 expressions include not only constant expressions such as those that
 appear in array bounds or as nontype template arguments but also general
 expressions (i.e., non-constant expressions) inside `sizeof`,
 `decltype`, and other contexts that allow non-constant expressions. The
+substitution proceeds in lexical order and stops when a condition that
+causes deduction to fail is encountered. The equivalent substitution in
+exception specifications is done only when the *exception-specification*
+is instantiated, at which point a program is ill-formed if the
+substitution results in an invalid type or expression.
+``` cpp
+template <class T> struct A { using X = typename T::X; };
+template <class T> typename T::X f(typename A<T>::X);
+template <class T> void f(...) { }
+template <class T> auto g(typename A<T>::X) -> typename T::X;
+template <class T> void g(...) { }
+void h() {
+  f<int>(0); // OK, substituting return type causes deduction to fail
+  g<int>(0); // error, substituting parameter type instantiates A<int>
+}
+```
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
+ill-formed, with a diagnostic required, if written using the substituted
+arguments. If no diagnostic is required, the program is still
+ill-formed. Access checking is done as part of the substitution process.
+Only invalid types and expressions in the immediate context of the
+function type and its template parameter types can result in a deduction
+failure. The evaluation of the substituted types and expressions can
+result in side effects such as the instantiation of class template
+specializations and/or function template specializations, the generation
+of implicitly-defined functions, etc. Such side effects are not in the
 “immediate context” and can result in the program being ill-formed.
 ``` cpp
 struct X { };
 struct Y {
 For a function parameter pack that occurs at the end of the
 *parameter-declaration-list*, the type `A` of each remaining argument of
 the call is compared with the type `P` of the *declarator-id* of the
 function parameter pack. Each comparison deduces template arguments for
 subsequent positions in the template parameter packs expanded by the
+function parameter pack. When a function parameter pack appears in a
+non-deduced context ([[temp.deduct.type]]), the type of that parameter
+pack is never deduced.
 ``` cpp
 template<class ... Types> void f(Types& ...);
 template<class T1, class ... Types> void g(T1, Types ...);
+template<class T1, class ... Types> void g1(Types ..., T1);
 void h(int x, float& y) {
   const int z = x;
   f(x, y, z);                  // Types is deduced to int, float, const int
   g(x, y, z);                  // T1 is deduced to int; Types is deduced to float, int
+  g1(x, y, z);                 // error: Types is not deduced
+  g1<int, int, int>(x, y, z);  // OK, no deduction occurs
 }
 ```
 If `P` is not a reference type:
 the address of an overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
 `P` and `A`, and the deduction is done as described in
 [[temp.deduct.type]].
+A placeholder type ([[dcl.spec.auto]]) in the return type of a function
+template is a non-deduced context. If template argument deduction
+succeeds for such a function, the return type is determined from
+instantiation of the function body.
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
 Template argument deduction is done by comparing the return type of the
+conversion function template (call it `P`) with the type that is
+required as the result of the conversion (call it `A`; see
+[[dcl.init]], [[over.match.conv]], and [[over.match.ref]] for the
+determination of that type) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
 transformations of `P` in the remainder of this section.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
   parameter types for which the function call has arguments.[^7]
+- In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
+- The *expression* of a *decltype-specifier*.
 - A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
 - A function parameter pack that does not occur at the end of the
+  *parameter-declaration-list*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
 non-deduced types. If a type is specified as `A<T>::B<T2>`, both `T` and
 // A<int>::X
 // i is explicitly specified to be 77, b.ym must be convertible
 // to B<77>::Y
 ```
+If `P` has a form that contains `<i>`, and if the type of the
+corresponding value of `A` differs from the type of `i`, deduction
+fails. If `P` has a form that contains `[i]`, and if the type of `i` is
+not an integral type, deduction fails.[^8]
 ``` cpp
 template<int i> class A { /* ... */ };
 template<short s> void f(A<s>);
 void k1() {
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [except.spec]: except.md#except.spec
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda]: expr.md#expr.prim.lambda

Diff to HTML by rtfpessoa