How can you detect whether a call result is valid - c++

Question

I'm trying to create a trait that detects whteher type Apply has a valid result when called with 2 arguments. I would expect the static_assert in the code not to hit because the result of apply is a valid one (dividing float). Why does this assert hit, and how would I change the trait in such a way that all the valid overloads for apply are detected as true_type or constexpr bool true.
#include <type_traits>
#include <functional>
struct Apply
{
template<typename T1, typename T2>
float apply(const T1& a, const T2& b) const
{
return a / b;
}
};
struct ApplyInvoker
{
Apply a;
template<typename... Args>
auto operator()(Args&&... args)
{
return a.apply(std::forward<Args>(args)...);
}
};
template <class Void, class... T>
struct ValidCall : std::false_type
{
};
template <class... T>
struct ValidCall<
std::void_t<decltype(std::invoke(std::declval<ApplyInvoker>(), std::declval<T>()...))>,
T...>
: std::true_type
{
};
template<typename T1, typename T2>
constexpr bool CanApply = ValidCall<void, T1, T2>::value;
int main()
{
static_assert(CanApply<float, float>);
}

Answer 1

You're using your template as:
template<typename T1, typename T2>
constexpr bool CanApply = ValidCall<T1, T2>::value;
But the primary is declared as:
template <class Void, class... T>
struct ValidCall;
That first template parameter is named Void because it has to be void - that's what the specialization is matching against. So you have to do it this way:
template<typename T1, typename T2>
constexpr bool CanApply = ValidCall<void, T1, T2>::value;
// ^~~~
But also, this is C++17, and we have a type trait for that:
template<typename T1, typename T2>
constexpr bool CanApply = std::is_invocable_v<ApplyInvoker, T1, T2>;
The problem is that neither Apply nor ApplyInvoker actually work with type traits. Apply advertises itself as being invocable with any two arguments - there is no way to detect otherwise. ApplyInvoker advertises itself as being invocable with any number of arguments - but in a way that will lead to a hard compiler error if you try to find out with the wrong set of them. Both these types are what we would call SFINAE-unfriendly - they're not friendly to type traits, they're not testable.
If you want them to actually be testable, then you need to rewrite both as follows:
struct Apply
{
template<typename T1, typename T2>
float apply(const T1& a, const T2& b) const
-> decltype(float(a / b))
{
return a / b;
}
};
struct ApplyInvoker
{
Apply a;
template <typename... Args>
auto operator()(Args&&... args)
-> decltype(a.apply(std::forward<Args>(args)...)
{
return a.apply(std::forward<Args>(args)...);
}
};
Or something similar.