Why does same_as concept check type equality twice?

by

Interesting question. I have recently watched Andrew Sutton’s talk on Concepts, and in the Q&A session someone asked the following question (timestamp in the following link):
CppCon 2018: Andrew Sutton “Concepts in 60: Everything you need to know and nothing you don’t”

So the question boils down to: If I have a concept that says A && B && C, another says C && B && A, would those be equivalent? Andrew answered yes, but pointed out the fact the compiler has some internal methods (that is transparent to the user) to decompose the concepts into atomic logical propositions (atomic constraints as Andrew worded the term) and check whether they are equivalent.

Now look at what cppreference says about std::same_as:

std::same_as<T, U> subsumes std::same_as<U, T> and vice versa.

It is basically an “if-and-only-if” relationship: they imply each other. (Logical Equivalence)

My conjecture is that here the atomic constraints are std::is_same_v<T, U>. The way compilers treat std::is_same_v might make them think std::is_same_v<T, U> and std::is_same_v<U, T> as two different constraints (they are different entities!). So if you implement std::same_as using only one of them:

template< class T, class U >
concept same_as = detail::SameHelper<T, U>;

Then std::same_as<T, U> and std::same_as<U, T> would “explode” to different atomic constrains and become not equivalent.

Well, why does the compiler care?

Consider this example:

#include <type_traits>
#include <iostream>
#include <concepts>

template< class T, class U >
concept SameHelper = std::is_same_v<T, U>;

template< class T, class U >
concept my_same_as = SameHelper<T, U>;

template< class T, class U> requires my_same_as<U, T>
void foo(T a, U b) {
    std::cout << "Not integral" << std::endl;
}

template< class T, class U> requires (my_same_as<T, U> && std::integral<T>)
void foo(T a, U b) {
    std::cout << "Integral" << std::endl;
}

int main() {
    foo(1, 2);
    return 0;
}

Ideally, my_same_as<T, U> && std::integral<T> subsumes my_same_as<U, T>; therefore, the compiler should select the second template specialization, except … it does not: the compiler emits an error error: call of overloaded 'foo(int, int)' is ambiguous.

The reason behind this is that since my_same_as<U, T> and my_same_as<T, U> does not subsume each other, my_same_as<T, U> && std::integral<T> and my_same_as<U, T> become incomparable (on the partially ordered set of constraints under the relation of subsumption).

However, if you replace

template< class T, class U >
concept my_same_as = SameHelper<T, U>;

with

template< class T, class U >
concept my_same_as = SameHelper<T, U> && SameHelper<U, T>;

The code compiles.

More Related Contents:

  1. Can I take the address of a function defined in standard library?
  2. Can class template constructors have a redundant template parameter list in c++20
  3. Class type non-type template parameter initialization does not compile
  4. Will consteval functions allow template parameters dependent on function arguments?
  5. Familiar template syntax for generic lambdas
  6. In which access control context are concepts evaluated?
  7. Why don’t I need to specify “typename” before a dependent type in C++20?
  8. Order of evaluation of arguments using std::cout
  9. Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?
  10. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  11. Do distinct functions have distinct addresses?
  12. Why class data members can’t be initialized by direct initialization syntax?
  13. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  14. Is a pointer with the right address and type still always a valid pointer since C++17?
  15. What is the C++ compiler required to do with ill-formed programs according to the Standard?
  16. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  17. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  18. “inline” keyword vs “inlining” concept
  19. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  20. When instantiating a template, should members of its incomplete argument types be visible?
  21. Which headers in the C++ standard library are guaranteed to include another header?
  22. How can an incomplete type be used as a template parameter to vector here?
  23. Why was the space character not chosen for C++14 digit separators?
  24. Erasing vector::end from vector
  25. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  26. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  27. Is it a strict aliasing violation to alias a struct as its first member?
  28. What is the modern, correct way to do type punning in C++?
  29. Why must a std::ranges::filter_view object be non-const for querying its elements?
  30. Overload resolution with ref-qualifiers

Leave a Comment