Is the expression `requires { typename enable_if_t>; }` the same as `fun_v` "by definition" for any meta-predicate fun_v?

Question

I'm reading Josuttis' C++20 the Complete Guide, and I think I've absorbed that a clause like the one in the template below

template<typename T>
requires requires { typename std::remove_const_t<T>; }
…

is completely useless as it resolves to requires true because remove_const_t always returns a type when given a type.

However, I reasoned, that's not the case, for instance, for enable_if, so I came up with

requires { typename std::enable_if_t<std::is_integral_v<T>>; }

Now, since the requires expression simply checks that the requirements in the {…} are well-formed, I think that's basically what the following does

std::is_integral_v<T>

It seems pretty uncontroversial to me, but I'm asking because I'm new to C++ concepts and it is perfectly possible that I'm making a mistake.

Answer 1

It works because std::enable_if is implemented as follows:

template<bool B, class T = void> struct enable_if {};

template<class T> struct enable_if<true, T> { typedef T type; };

When the fun_v<T> is true, the second template is used and the constraint is satisfied, since it simply checks if type is well-formed (in this case, it must simply exist, and does not matter if it is defined as void or something else), and likewise, when the fun_v<T> is false, the first template is used and the constraint is not satisfied, since type is not well-formed.

So, you can use std::enable_if to create a constraint in this way, but it is nonsense. In fact, if you read the information about what is std::enable_if, you will find this sentence: "This metafunction is a convenient way to leverage SFINAE prior to C++20's concepts, in particular for conditionally removing functions from the candidate set based on type traits, allowing separate function overloads or specializations based on those different type traits". Then, there is no sense to mix SFINAE and C++20's concepts.