[temp.deduct.call] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpa9mnvfi_/{from.md → to.md} +41 -24

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

@@ -1,21 +1,21 @@
 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
-parameter type (call it `P`) that contains *template-parameter*s that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
-`std::initializer_list<P^{\prime}>` or `P`'`[N]` for some `P`' and `N`
-and the argument is a non-empty initializer list [[dcl.init.list]], then
-deduction is performed instead for each element of the initializer list
-independently, taking `P`' as separate function template parameter types
-`P`'_i and the iᵗʰ initializer element as the corresponding argument. In
-the `P`'`[N]` case, if `N` is a non-type template parameter, `N` is
-deduced from the length of the initializer list. Otherwise, an
-initializer list argument causes the parameter to be considered a
-non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
@@ -153,19 +153,20 @@ that allow a difference:
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
-- If `P` is a class and `P` has the form *simple-template-id*, then the
- transformed `A` can be a derived class `D` of the deduced `A`.
- Likewise, if `P` is a pointer to a class of the form
- *simple-template-id*, the transformed `A` can be a pointer to a
- derived class `D` pointed to by the deduced `A`. However, if there is
- a class `C` that is a (direct or indirect) base class of `D` and
- derived (directly or indirectly) from a class `B` and that would be a
- valid deduced `A`, the deduced `A` cannot be `B` or pointer to `B`,
- respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
@@ -184,11 +185,11 @@ that allow a difference:
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
-[*Note 1*: If a *template-parameter* is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
@@ -197,14 +198,14 @@ pointer-to-member-function type:
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
-  members of the set. If deduction succeeds for only one of the overload
- set members, that member is used as the argument value for the
- deduction. If deduction succeeds for more than one member of the
- overload set the parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
@@ -238,5 +239,21 @@ template <class T> T g(T);
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]

 #### Deducing template arguments from a function call <a id="temp.deduct.call">[[temp.deduct.call]]</a>
 Template argument deduction is done by comparing each function template
+parameter type (call it `P`) that contains template parameters that
 participate in template argument deduction with the type of the
 corresponding argument of the call (call it `A`) as described below. If
 removing references and cv-qualifiers from `P` gives
+$\tcode{std::initializer_list<P}^{\prime}\tcode{>}$ or `P`'`[N]` for
+some `P`' and `N` and the argument is a non-empty initializer list
+[[dcl.init.list]], then deduction is performed instead for each element
+of the initializer list independently, taking `P`' as separate function
+template parameter types `P`'_i and the iᵗʰ initializer element as the
+corresponding argument. In the `P`'`[N]` case, if `N` is a constant
+template parameter, `N` is deduced from the length of the initializer
+list. Otherwise, an initializer list argument causes the parameter to be
+considered a non-deduced context [[temp.deduct.type]].
 [*Example 1*:
 ``` cpp
 template<class T> void f(std::initializer_list<T>);
   transformed `A`.
 - The transformed `A` can be another pointer or pointer-to-member type
   that can be converted to the deduced `A` via a function pointer
   conversion [[conv.fctptr]] and/or qualification conversion
   [[conv.qual]].
+- If `P` is a class and `P` has the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, then the transformed
+  `A` can be a derived class `D` of the deduced `A`. Likewise, if `P` is
+ a pointer to a class of the form *simple-template-id* or
+  `typename`ₒₚₜ  *splice-specialization-specifier*, the transformed `A`
+ can be a pointer to a derived class `D` of the class pointed to by the
+ deduced `A`. However, if there is a class `C` that is a (direct or
+ indirect) base class of `D` and derived (directly or indirectly) from
+ a class `B` and that would be a valid deduced `A`, the deduced `A`
+  cannot be `B` or pointer to `B`, respectively.
   \[*Example 5*:
   ``` cpp
   template <typename... T> struct X;
   template <> struct X<> {};
   template <typename T, typename... Ts>
 These alternatives are considered only if type deduction would otherwise
 fail. If they yield more than one possible deduced `A`, the type
 deduction fails.
+[*Note 1*: If a template parameter is not used in any of the function
 parameters of a function template, or is used only in a non-deduced
 context, its corresponding *template-argument* cannot be deduced from a
 function call and the *template-argument* must be explicitly
 specified. — *end note*]
 - If the argument is an overload set containing one or more function
   templates, the parameter is treated as a non-deduced context.
 - If the argument is an overload set (not containing function
   templates), trial argument deduction is attempted using each of the
+  members of the set whose associated constraints [[temp.constr.constr]]
+ are satisfied. If all successful deductions yield the same deduced
+ `A`, that deduced `A` is the result of deduction; otherwise, the
+  parameter is treated as a non-deduced context.
 [*Example 6*:
 ``` cpp
 // Only one function of an overload set matches the call so the function parameter is a deduced context.
 int i = f(1, g);    // calls f(int, int (*)(int))
 ```
 — *end example*]
+[*Example 9*:
+``` cpp
+// All arguments for placeholder type deduction[dcl.type.auto.deduct] yield the same deduced type.
+template<bool B> struct X {
+  static void f(short) requires B;  // #1
+  static void f(short);             // #2
+};
+void test() {
+  auto x = &X<true>::f;     // OK, deduces void(*)(short), selects #1
+  auto y = &X<false>::f;    // OK, deduces void(*)(short), selects #2
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa