With P1141R1 voted in, how many types are deduced from multiple deduced parameters with the same constraint?

user_6374236 0
Viewed 154

According to Concepts TS, while an unconstrained deduced parameter yield new template type parameter each time, constrained deduced parameters yield only one template type parameter per constraint:

[](auto a, auto b) // IS-A
[]<class ArgA, class ArgB>(ArgA a, ArgB b)

[](Constraint a, Constraint b) // IS-A
[]<Constraint Type>(Type a, Type b)

Now, the P1141R1 was voted in (see Herb Sutter's Trip Report) and it re-introduces the short syntax for constrained deduced parameters with "adjective syntax" for constrained auto:

void fun(Constraint auto a, Constraint auto b);

with notion, that "The appearance of auto (including Constraint auto) in a parameter list tells us that we are dealing with a function template."

There is, however, no information on how many separate types such syntax would yield. So, the question is: for two constrained deduced parameters with the same constraint (as above), would there be a template with one type parameter, or are the rules relaxed due to presence of auto keyword?

Edit: template type argument parameter.

c++-concepts c++20 template-meta-programming c++
2 Answers

People should really stop writing misleading trip reports with links to outdated papers, at least without a giant flashing neon pink disclaimer. The paper voted in is P1141R2, which will be publicly available in a few weeks. The approved design is roughly parts 1, 3, and 4 of P1141R1.

You get independent binding, i.e., two template parameters in your example:

An abbreviated function template is equivalent to a function template (17.6.5) whose template-parameter-list includes one invented type template-parameter for each occurrence of a placeholder type in the decl-specifier-seq of a parameter-declaration in the function’s parameter-type-list, in order of appearance.

This has been the expected direction since at least early this year.

user_27567190

This declaration:

void fun(Constraint auto a, Constraint auto b);

means that we do so-called "independent binding".

It means the same thing as the longer partial-concept-id syntax:

template <Constraint _T, Constraint _U>
void fun(_T a, _U b);

and the even longer full requires-clause syntax:

template <typename _T, typename _U>
    requires Constraint<_T> && Constraint<_U>
void fun(_T a, _U b);

except that you do not have access to the names _T and _U (if you need those type names, you will need to resort to one of the longer syntax options).

For a lengthy list of arguments as to why "independent binding" is a better choice than "consistent binding", see P0464: Revisiting the meaning of foo(ConceptName, ConceptName).

user_20690640
Related