CODEWITHSUNDEEP
c++standardsc++20c++-concepts
mutableVoid
mutableVoid

Reputation: 1526

C++ partial concept id: What is the reason for the explicit template specification order / special status of first argument?

I started experimenting with the C++20 feature of concepts and was very pleased when I realized that it is possible to partially explicitly provide template arguments for concepts. I read the cppreference article and did not find that mentioned there.

But then I realized something strange: the order of specification of template arguments is reversed to what I would have expected. When providing one explicite template argument, it replaces the second template in the template list: 

#include <concepts>
#include <type_traits>

/// Concept in order to deduce if sth. is base of sth else
template <typename Impl, typename Base>             //XXX: here the order of Impl and Base are not 
concept Implements = std::is_base_of_v<std::remove_reference_t<Base>, // what I would've expected.
                                       std::remove_reference_t<Impl>>;
/// Example Base class impl
struct BaseExample {};
/// Implementation of BaseExample
struct ImplExample : BaseExample {};

/// Function in which the concept is applied
template <Implements<BaseExample>... Baes> void f(Baes &&... ) {}//} ((void)b, ...); }

int main() {
  (void) std::is_base_of_v<BaseExample, std::remove_reference_t<ImplExample &&>>; //< true
  (void) std::is_base_of_v<BaseExample, std::remove_reference_t<ImplExample&>>;  //< true
  f(ImplExample{}, ImplExample{});
}

From my point of view the possibility to partially provide explicit template arguments makes sense, as the argument against partial template specification for classes do not apply here and make concepts more general. Now I wonder:

  1. Will partial explicit template specifications (likely) be allowed when the standard is released?
  2. Will this order of specifications likely stay the same or is this a bug?
  3. How would I answer this question for myself? From what I understand the c++20 standard is not ready by now and I found a list of C++ Standard Committee Papers, of which I briefly searched the headlines of the ones proposed in 2020 for 'concept'. Is checking these papers the way to go, or is there an accessible single document which combines the points the authors currently agreed upon?

The code can be found here.

edit After posting this I checked the behavior when three template arguments are specified. It looks like I misinterpreted the specification order: The first argument is 'held free' to contain the argument to be checked, and the explicit specifications start with the second argument. This can be seen here. Even though I figured out the reasoning behind the order of specification I would be very interested in the answers to questions above.

Upvotes: 2

Views: 267

Answers (1)

Davis Herring
Davis Herring

Reputation: 39878

Yes, partial-concept-ids are surely a C++20 thing. The special status of the first argument, while surprising, allows cases like std::constructible_from which is declared as

template<class T,class ...Args>
concept constructible_from=…;

std::constructible_from<int,int> is a type-constraint that requires that whatever it introduces be constructible from two int arguments. However, it can also be an expression, in which case it reports whether an int can be constructed from an int (spoilers: true), but that potential confusion exists regardless of the argument order.

If T had to go at the end, there would be no way of using such a concept: only template argument deduction or default template arguments can supply values for a template parameter beyond a parameter pack, and neither of those applies here.

Every mailing posted at the papers site you linked includes the latest draft of the standard, and alternate mailings include annotations as to what papers were adopted. Or you can just visit the draft’s repository (at least if you’re happy reading LaTeX).

Upvotes: 3

Related Questions