[temp.deduct.type] - C++20 → C++23

Files changed (1) hide show

tmp/tmp541svvw2/{from.md → to.md} +99 -59

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

@@ -20,12 +20,12 @@ deduction fails. The type of a type parameter is only deduced from an
 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
 templates, and non-type values:
-- A function type includes the types of each of the function parameters
- and the return type.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
   includes the types, templates, and non-type values referenced by the
   template argument list of the specialization.
@@ -98,14 +98,14 @@ inconsistent template argument deductions:
 ``` cpp
 template<class T> void f(T x, T y) { ... }
 struct A { ... };
 struct B : A { ... };
 void g(A a, B b) {
-  f(a,b);           // error: T could be A or B
-  f(b,a);           // error: T could be A or B
-  f(a,a);           // OK: T is A
-  f(b,b);           // OK: T is B
 }
 ```
 Here is an example where two template arguments are deduced from a
 single function parameter/argument pair. This can lead to conflicts that
@@ -117,13 +117,32 @@ template <class T, class U> void f(  T (*)( T, U, U )  );
 int g1( int, float, float);
 char g2( int, float, float);
 int g3( int, char, float);
 void r() {
-  f(g1);            // OK: T is int and U is float
-  f(g2);            // error: T could be char or int
-  f(g3);            // error: U could be char or float
 }
 ```
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument
@@ -153,49 +172,50 @@ void t() {
 }
 ```
 — *end example*]
-A template type argument `T`, a template template argument `TT` or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
-T
-cv T
 T*
 T&
 T&&
-T[integer-constant]
-template-name<T>  (where template-name refers to a class template)
-type(T)
-T()
-T(T)
-T type::*
-type T::*
-T T::*
-T (type::*)()
-type (T::*)()
-type (type::*)(T)
-type (T::*)(T)
-T (type::*)(T)
-T (T::*)()
-T (T::*)(T)
-type[i]
-template-name<i>  (where template-name refers to a class template)
-TT<T>
-TT<i>
-TT<>
 ```
-where `(T)` represents a parameter-type-list [[dcl.fct]] where at least
-one parameter type contains a `T`, and `()` represents a
-parameter-type-list where no parameter type contains a `T`. Similarly,
-`<T>` represents template argument lists where at least one argument
-contains a `T`, `<i>` represents template argument lists where at least
-one argument contains an `i` and `<>` represents template argument lists
-where no argument contains a `T` or an `i`.
 If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
 the respective template argument list of `P` is compared with the
 corresponding argument Aᵢ of the corresponding template argument list of
 `A`. If the template argument list of `P` contains a pack expansion that
@@ -239,11 +259,11 @@ parameters of the top-level parameter-type-list of `P` and `A`,
 respectively, `Pᵢ` is adjusted if it is a forwarding reference
 [[temp.deduct.call]] and `Aᵢ` is an lvalue reference, in which case the
 type of `Pᵢ` is changed to be the template parameter type (i.e., `T&&`
 is changed to simply `T`).
-[*Note 2*: As a result, when `Pᵢ` is `T&&` and `Aᵢ` is `X&`, the
 adjusted `Pᵢ` will be `T`, causing `T` to be deduced as
 `X&`. — *end note*]
 [*Example 5*:
@@ -346,23 +366,40 @@ using V = decltype(sizeof 0);
 using V = S<int[42]>::Q;        // OK; T was deduced as std::size_t from the type int[42]
 ```
 — *end example*]
 [*Example 10*:
 ``` cpp
 template<class T, T i> void f(int (&a)[i]);
 int v[10];
 void g() {
-  f(v);                         // OK: T is std::size_t
 }
 ```
 — *end example*]
-[*Note 3*:
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
@@ -370,28 +407,28 @@ template<int i> void f1(int a[10][i]);
 template<int i> void f2(int a[i][20]);
 template<int i> void f3(int (&a)[i][20]);
 void g() {
   int v[10][20];
-  f1(v);                        // OK: i deduced as 20
   f1<20>(v);                    // OK
   f2(v);                        // error: cannot deduce template-argument i
   f2<10>(v);                    // OK
-  f3(v);                        // OK: i deduced as 10
 }
 ```
 — *end note*]
-[*Note 4*:
 If, in the declaration of a function template with a non-type template
 parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
-[*Example 11*:
 ``` cpp
 template <int i> class A { ... };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
@@ -406,11 +443,11 @@ void k() {
 — *end example*]
 — *end note*]
-[*Note 5*:
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
@@ -430,13 +467,16 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
 named by the enclosing *simple-template-id*, deduction fails. If `P` has
 a form that contains `[i]`, and if the type of `i` is not an integral
-type, deduction fails.[^13]
-[*Example 12*:
 ``` cpp
 template<int i> class A { ... };
 template<short s> void f(A<s>);
 void k1() {
@@ -447,20 +487,20 @@ void k1() {
 template<const short cs> class B { };
 template<short s> void g(B<s>);
 void k2() {
   B<1> b;
-  g(b);             // OK: cv-qualifiers are ignored on template parameter types
 }
 ```
 — *end example*]
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer-to-member-function type.
-[*Example 13*:
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
@@ -468,38 +508,38 @@ void g(char,int);
 void h(int,int,int);
 void h(char,int);
 int m() {
   f(&g);            // error: ambiguous
-  f(&h);            // OK: void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
 — *end example*]
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
-[*Example 14*:
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
-  f(1);             // OK: call f<int>(1,7)
   f();              // error: cannot deduce T
-  f<int>();         // OK: call f<int>(5,7)
 }
 ```
 — *end example*]
 The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
-[*Example 15*:
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
@@ -507,15 +547,15 @@ A<B> ab;
 f(ab);              // calls f(A<B>)
 ```
 — *end example*]
-[*Note 6*: Template argument deduction involving parameter packs
 [[temp.variadic]] can deduce zero or more arguments for each parameter
 pack. — *end note*]
-[*Example 16*:
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
@@ -525,11 +565,11 @@ template<class ... Types> int f(void (*)(Types ...));
 void g(int, float);
 X<int> x1;                      // uses primary template
 X<int(int, float, double)> x2;  // uses partial specialization; ArgTypes contains float, double
 X<int(float, int)> x3;          // uses primary template
-Y<> y1;                         // use primary template; Types is empty
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```

 array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
 templates, and non-type values:
+- A function type includes the types of each of the function parameters,
+  the return type, and its exception specification.
 - A pointer-to-member type includes the type of the class object pointed
   to and the type of the member pointed to.
 - A type that is a specialization of a class template (e.g., `A<int>`)
   includes the types, templates, and non-type values referenced by the
   template argument list of the specialization.
 ``` cpp
 template<class T> void f(T x, T y) { ... }
 struct A { ... };
 struct B : A { ... };
 void g(A a, B b) {
+  f(a,b);           // error: T deduced as both A and B
+  f(b,a);           // error: T deduced as both A and B
+  f(a,a);           // OK, T is A
+  f(b,b);           // OK, T is B
 }
 ```
 Here is an example where two template arguments are deduced from a
 single function parameter/argument pair. This can lead to conflicts that
 int g1( int, float, float);
 char g2( int, float, float);
 int g3( int, char, float);
 void r() {
+  f(g1);            // OK, T is int and U is float
+  f(g2);            // error: T deduced as both char and int
+  f(g3);            // error: U deduced as both char and float
+}
+```
+Here is an example where the exception specification of a function type
+is deduced:
+``` cpp
+template<bool E> void f1(void (*)() noexcept(E));
+template<bool> struct A { };
+template<bool B> void f2(void (*)(A<B>) noexcept(B));
+void g1();
+void g2() noexcept;
+void g3(A<true>);
+void h() {
+  f1(g1);           // OK, E is false
+  f1(g2);           // OK, E is true
+  f2(g3);           // error: B deduced as both true and false
 }
 ```
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument
 }
 ```
 — *end example*]
+A template type argument `T`, a template template argument `TT`, or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
+\opt{cv} T
 T*
 T&
 T&&
+\opt{T}[\opt{i}]
+\opt{T}(\opt{T}) noexcept(\opt{i})
+\opt{T} \opt{T}::*
+\opt{TT}<T>
+\opt{TT}<i>
+\opt{TT}<TT>
+\opt{TT}<>
 ```
+where
+- `\opt{T}` represents a type or parameter-type-list that either
+  satisfies these rules recursively, is a non-deduced context in `P` or
+ `A`, or is the same non-dependent type in `P` and `A`,
+- `\opt{TT}` represents either a class template or a template template
+  parameter,
+- `\opt{i}` represents an expression that either is an `i`, is
+  value-dependent in `P` or `A`, or has the same constant value in `P`
+  and `A`, and
+- `noexcept(\opt{i})` represents an exception specification
+  [[except.spec]] in which the (possibly-implicit, see  [[dcl.fct]])
+  *noexcept-specifier*’s operand satisfies the rules for an `\opt{i}`
+  above.
+[*Note 2*: If a type matches such a form but contains no `T`s, `i`s, or
+`TT`s, deduction is not possible. — *end note*]
+Similarly, `<T>` represents template argument lists where at least one
+argument contains a `T`, `<i>` represents template argument lists where
+at least one argument contains an `i` and `<>` represents template
+argument lists where no argument contains a `T` or an `i`.
 If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
 the respective template argument list of `P` is compared with the
 corresponding argument Aᵢ of the corresponding template argument list of
 `A`. If the template argument list of `P` contains a pack expansion that
 respectively, `Pᵢ` is adjusted if it is a forwarding reference
 [[temp.deduct.call]] and `Aᵢ` is an lvalue reference, in which case the
 type of `Pᵢ` is changed to be the template parameter type (i.e., `T&&`
 is changed to simply `T`).
+[*Note 3*: As a result, when `Pᵢ` is `T&&` and `Aᵢ` is `X&`, the
 adjusted `Pᵢ` will be `T`, causing `T` to be deduced as
 `X&`. — *end note*]
 [*Example 5*:
 using V = S<int[42]>::Q;        // OK; T was deduced as std::size_t from the type int[42]
 ```
 — *end example*]
+The type of `B` in the *noexcept-specifier* `noexcept(B)` of a function
+type is `bool`.
 [*Example 10*:
+``` cpp
+template<bool> struct A { };
+template<auto> struct B;
+template<auto X, void (*F)() noexcept(X)> struct B<F> {
+  A<X> ax;
+};
+void f_nothrow() noexcept;
+B<f_nothrow> bn;                // OK, type of X deduced as bool
+```
+— *end example*]
+[*Example 11*:
 ``` cpp
 template<class T, T i> void f(int (&a)[i]);
 int v[10];
 void g() {
+  f(v);                         // OK, T is std::size_t
 }
 ```
 — *end example*]
+[*Note 4*:
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
 template<int i> void f2(int a[i][20]);
 template<int i> void f3(int (&a)[i][20]);
 void g() {
   int v[10][20];
+  f1(v);                        // OK, i deduced as 20
   f1<20>(v);                    // OK
   f2(v);                        // error: cannot deduce template-argument i
   f2<10>(v);                    // OK
+  f3(v);                        // OK, i deduced as 10
 }
 ```
 — *end note*]
+[*Note 5*:
 If, in the declaration of a function template with a non-type template
 parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
+[*Example 12*:
 ``` cpp
 template <int i> class A { ... };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 — *end example*]
 — *end note*]
+[*Note 6*:
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 If `P` has a form that contains `<i>`, and if the type of `i` differs
 from the type of the corresponding template parameter of the template
 named by the enclosing *simple-template-id*, deduction fails. If `P` has
 a form that contains `[i]`, and if the type of `i` is not an integral
+type, deduction fails.[^14]
+If `P` has a form that includes `noexcept(i)` and the type of `i` is not
+`bool`, deduction fails.
+[*Example 13*:
 ``` cpp
 template<int i> class A { ... };
 template<short s> void f(A<s>);
 void k1() {
 template<const short cs> class B { };
 template<short s> void g(B<s>);
 void k2() {
   B<1> b;
+  g(b);             // OK, cv-qualifiers are ignored on template parameter types
 }
 ```
 — *end example*]
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer-to-member-function type.
+[*Example 14*:
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void h(int,int,int);
 void h(char,int);
 int m() {
   f(&g);            // error: ambiguous
+  f(&h);            // OK, void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
 — *end example*]
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
+[*Example 15*:
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
+  f(1);             // OK, calls f<int>(1,7)
   f();              // error: cannot deduce T
+  f<int>();         // OK, calls f<int>(5,7)
 }
 ```
 — *end example*]
 The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
+[*Example 16*:
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 f(ab);              // calls f(A<B>)
 ```
 — *end example*]
+[*Note 7*: Template argument deduction involving parameter packs
 [[temp.variadic]] can deduce zero or more arguments for each parameter
 pack. — *end note*]
+[*Example 17*:
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
 void g(int, float);
 X<int> x1;                      // uses primary template
 X<int(int, float, double)> x2;  // uses partial specialization; ArgTypes contains float, double
 X<int(float, int)> x3;          // uses primary template
+Y<> y1;                         // uses primary template; Types is empty
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```

Diff to HTML by rtfpessoa