[temp.fct] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpd0da7hfm/{from.md → to.md} +23 -18

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

@@ -20,11 +20,11 @@ templates and non-template functions [[dcl.fct]] in the same
 scope. — *end note*]
 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.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
@@ -90,11 +90,11 @@ template <int K, int L> A<K+L> f(A<K>, A<L>);   // same as #1
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
-[*Note 2*: Most expressions that use template parameters use non-type
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
@@ -121,12 +121,12 @@ signature of a function template with external linkage. — *end note*]
 For determining whether two dependent names [[temp.dep]] are equivalent,
 only the name itself is considered, not the result of name lookup.
 [*Note 5*: If such a dependent name is unqualified, it is looked up
-from the first declaration of the function template
-[[temp.dep.candidate]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
@@ -182,34 +182,35 @@ declared with a *type-constraint*, and if either *template-head* has a
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
-- if they declare non-type template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
-- if they declare template template parameters, their template
- parameters are equivalent.
 When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
 If the validity or meaning of the program depends on whether two
 constructs are equivalent, and they are functionally equivalent but not
 equivalent, the program is ill-formed, no diagnostic required.
-Furthermore, if two function templates that do not correspond
-- have the same name,
 - have corresponding signatures [[basic.scope.scope]],
-- would declare the same entity [[basic.link]] considering them to
- correspond, and
 - accept and are satisfied by the same set of template argument lists,
-the program is ill-formed, no diagnostic required.
 [*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
@@ -259,20 +260,24 @@ function type. The deduction process determines whether one of the
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
-To produce the transformed template, for each type, non-type, or
-template template parameter (including template parameter packs
-[[temp.variadic]] thereof) synthesize a unique type, value, or class
-template respectively and substitute it for each occurrence of that
-parameter in the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
-synthesized for a non-type template parameter is also a unique
 synthesized type. — *end note*]
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order

 scope. — *end note*]
 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.[^8]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
 template <int I, int J> A<I-J> f(A<I>, A<J>);   // different from #1
 ```
 — *end example*]
+[*Note 2*: Most expressions that use template parameters use constant
 template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 For determining whether two dependent names [[temp.dep]] are equivalent,
 only the name itself is considered, not the result of name lookup.
 [*Note 5*: If such a dependent name is unqualified, it is looked up
+from a first declaration of the function template
+[[temp.res.general]]. — *end note*]
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 corresponding *constraint-expression*s are equivalent. Two
 *template-parameter*s are *equivalent* under the following conditions:
 - they declare template parameters of the same kind,
 - if either declares a template parameter pack, they both do,
+- if they declare constant template parameters, they have equivalent
   types ignoring the use of *type-constraint*s for placeholder types,
   and
+- if they declare template template parameters, their *template-head*s
+  are equivalent.
 When determining whether types or *type-constraint*s are equivalent, the
 rules above are used to compare expressions involving template
 parameters. Two *template-head*s are *functionally equivalent* if they
 accept and are satisfied by [[temp.constr.constr]] the same set of
 template argument lists.
 If the validity or meaning of the program depends on whether two
 constructs are equivalent, and they are functionally equivalent but not
 equivalent, the program is ill-formed, no diagnostic required.
+Furthermore, if two declarations A and B of function templates
+- introduce the same name,
 - have corresponding signatures [[basic.scope.scope]],
+- would declare the same entity, when considering A and B to correspond
+ in that determination [[basic.link]], and
 - accept and are satisfied by the same set of template argument lists,
+but do not correspond, the program is ill-formed, no diagnostic
+required.
 [*Note 7*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 If both deductions succeed, the partial ordering selects the more
 constrained template (if one exists) as determined below.
+To produce the transformed template, for each type, constant, type
+template, variable template, or concept template parameter (including
+template parameter packs [[temp.variadic]] thereof) synthesize a unique
+type, value, class template, variable template, or concept,
+respectively, and substitute it for each occurrence of that parameter in
+the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
+synthesized for a constant template parameter is also a unique
 synthesized type. — *end note*]
+A synthesized template has the same *template-head* as its corresponding
+template template parameter.
 Each function template M that is a member function is considered to have
 a new first parameter of type X(M), described below, inserted in its
 function parameter list. If exactly one of the function templates was
 considered by overload resolution via a rewritten candidate
 [[over.match.oper]] with a reversed order of parameters, then the order

Diff to HTML by rtfpessoa