Is there a standard generalization of void_t for other types?

Question

In C++17, we have std::void_t, which makes SFINAE look a lot nicer:

template <typename T>
std::void_t<decltype(T::prop)> foo() { /* stuff */ }

The template function will exist only if T::prop exists.

If T::prop exists, the template function foo() would be equivalent to this:

template <typename T>
void foo() { /* stuff */ }

Otherwise, the code is equivalent to not declaring foo() at all.

Is there any generalization of std::void_t for other types in the standard library, such as the following:

template<typename T, typename...>
using generic_t = T;

so that the code below would be valid?

template <typename T>
std::generic_t<int, decltype(T::prop)> foo() { /* stuff */ }

which would be equivalent to

template <typename T>
int foo() { /* stuff */ }

if T::prop exists?

Answer 1

Why do you need such a generalization? void_t is a little special in that it helps you easily write type traits, because you can have a primary with some type defaulted to void and a specialization which uses void_t. For instance:

template <class T, class = void>
struct has_prop : std::false_type { };

template <class T>
struct has_prop<T, std::void_t<decltype(T::prop)>> : std::true_type { };

It's not that there's anything special about void, you just need some agreed upon type between the primary and the specialization.

void_t doesn't make much sense if you're just using it directly in SFINAE though. You could just stick the expression somewhere else:

template <typename T, class = decltype(T::prop)>
void foo() { /* stuff */ }

at which point the return type is totally separate from the condition you're checking anyway, so if you want int:

template <typename T, class = decltype(T::prop)>
int foo() { /* stuff */ }

Answer 2

It probably does not exist. It is not linked in the documentation and therefore I doubt its existence. But you can build such type on your own:

template <class type, class... sfinae_expressions>
using generic_t = type;