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

Files changed (1) hide show

tmp/tmp0iaqemvq/{from.md → to.md} +60 -51

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

@@ -2,13 +2,13 @@
 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
-value for a non-type parameter, or a template for a template parameter)
-that will make `P`, after substitution of the deduced values (call it
-the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
@@ -18,52 +18,57 @@ pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
 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,
   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.
 - An array type includes the array element type and the value of the
   array bound.
-In most cases, the types, templates, and non-type values that are used
-to compose `P` participate in template argument deduction. That is, they
-may be used to determine the value of a template argument, and template
-argument deduction fails if the value so determined is not consistent
-with the values determined elsewhere. In certain contexts, however, the
-value does not participate in type deduction, but instead uses the
-values of template arguments that were either deduced elsewhere or
-explicitly specified. If a template parameter is used only in
-non-deduced contexts and is not explicitly specified, template argument
-deduction fails.
-[*Note 1*: Under [[temp.deduct.call]], if `P` contains no
-*template-parameter*s that appear in deduced contexts, no deduction is
-done, so `P` and `A` need not have the same form. — *end note*]
 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.
 - A function parameter for which the associated argument is an overload
-  set [[over.over]], and one or more of the following apply:
-  - more than one function matches the function parameter type
     (resulting in an ambiguous deduction), or
-  - no function matches the function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
@@ -172,13 +177,15 @@ 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
 \opt{cv} T
 T*
 T&
@@ -187,47 +194,48 @@ T&&
 \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
-is not the last template argument, the entire template argument list is
-a non-deduced context. If `Pᵢ` is a pack expansion, then the pattern of
-`Pᵢ` is compared with each remaining argument in the template argument
-list of `A`. Each comparison deduces template arguments for subsequent
-positions in the template parameter packs expanded by `Pᵢ`. During
-partial ordering [[temp.deduct.partial]], if `Aᵢ` was originally a pack
-expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
@@ -328,11 +336,11 @@ where type is `X<int>` and `T` is `char[6]`.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
-When the value of the argument corresponding to a non-type template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
@@ -419,12 +427,12 @@ void g() {
 — *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*:
@@ -465,13 +473,14 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 — *end note*]
 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*:
@@ -531,11 +540,11 @@ void g() {
 }
 ```
 — *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*:

 Template arguments can be deduced in several different contexts, but in
 each case a type that is specified in terms of template parameters (call
 it `P`) is compared with an actual type (call it `A`), and an attempt is
 made to find template argument values (a type for a type parameter, a
+value for a constant template parameter, or a template for a template
+template parameter) that will make `P`, after substitution of the
+deduced values (call it the deduced `A`), compatible with `A`.
 In some cases, the deduction is done using a single set of types `P` and
 `A`, in other cases, there will be a set of corresponding types `P` and
 `A`. Type deduction is done independently for each `P/A` pair, and the
 deduced template argument values are then combined. If type deduction
 remains neither deduced nor explicitly specified, template argument
 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 constant template argument 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 constant template argument values
+ referenced by the template argument list of the specialization.
 - An array type includes the array element type and the value of the
   array bound.
+In most cases, the types, templates, and constant template argument
+values that are used to compose `P` participate in template argument
+deduction. That is, they may be used to determine the value of a
+template argument, and template argument deduction fails if the value so
+determined is not consistent with the values determined elsewhere. In
+certain contexts, however, the value does not participate in type
+deduction, but instead uses the values of template arguments that were
+either deduced elsewhere or explicitly specified. If a template
+parameter is used only in non-deduced contexts and is not explicitly
+specified, template argument deduction fails.
+[*Note 1*: Under [[temp.deduct.call]], if `P` contains no template
+parameters that appear in deduced contexts, no deduction is done, so `P`
+and `A` need not have the same form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
+- A *pack-index-specifier* or a *pack-index-expression*.
+- A *type-constraint*.
 - The *expression* of a *decltype-specifier*.
+- The *constant-expression* of a *splice-specifier*.
+- A constant 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.
 - A function parameter for which the associated argument is an overload
+  set such that one or more of the following apply:
+  - functions whose associated constraints are satisfied and that do not
+    all have the same function type match the function parameter type
     (resulting in an ambiguous deduction), or
+  - no function whose associated constraints are satisfied matches the
+    function parameter type, or
   - the overload set supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list [[dcl.init.list]] but the parameter does not have a
   type for which deduction from an initializer list is specified
 }
 ```
 — *end example*]
+A type template argument `T`, a constant template argument `i`, a
+template template argument `TT` denoting a class template or an alias
+template, or a template template argument `VV` denoting a variable
+template or a concept can be deduced if `P` and `A` have one of the
+following forms:
 ``` cpp
 \opt{cv} T
 T*
 T&
 \opt{T}(\opt{T}) noexcept(\opt{i})
 \opt{T} \opt{T}::*
 \opt{TT}<T>
 \opt{TT}<i>
 \opt{TT}<TT>
+\opt{TT}<VV>
 \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{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`,
+- `\opt{TT}` represents either a class template or a template template
+  parameter, 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, `<X>` represents template argument lists where at least one
+argument contains an X, where X is one of `T`, `i`, `TT`, or `VV`; and
+`<>` represents template argument lists where no argument contains a
+`T`, an `i`, a `TT`, or a `VV`.
+If `P` has a form that contains `<T>`, `<i>`, `<TT>`, or `<VV>`, 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 is not the last template argument, the
+entire template argument list is a non-deduced context. If `Pᵢ` is a
+pack expansion, then the pattern of `Pᵢ` is compared with each remaining
+argument in the template argument list of `A`. Each comparison deduces
+template arguments for subsequent positions in the template parameter
+packs expanded by `Pᵢ`. During partial ordering [[temp.deduct.partial]],
+if `Aᵢ` was originally a pack expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
 — *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
+When the value of the argument corresponding to a constant template
 parameter `P` that is declared with a dependent type is deduced from an
 expression, the template parameters in the type of `P` are deduced from
 the type of the value.
 [*Example 8*:
 — *end note*]
 [*Note 5*:
+If, in the declaration of a function template with a constant template
+parameter, the constant template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 [*Example 12*:
 — *end note*]
 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* or
+*splice-specialization-specifier*, deduction fails. If `P` has a form
+that contains `[i]`, and if the type of `i` is not an integral type,
+deduction fails.[^13]
 If `P` has a form that includes `noexcept(i)` and the type of `i` is not
 `bool`, deduction fails.
 [*Example 13*:
 }
 ```
 — *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*:

Diff to HTML by rtfpessoa