Find out if type is callable - c++

Question

I need to figure out if template argument is a callable object with non-void return value.
I've defined the following:
template<class T, class U = T>
struct is_callable
{
constexpr static const bool val = false;
};
template<class T>
struct is_callable<T, std::result_of_t<T()>>
{
constexpr static const bool val = true;
};
template<class T>
constexpr bool is_func = is_callable<T>::val;
But the following variables all are false
auto lambda = []() {return 3.0; };
auto intIsFunc = is_func<int>; //false -- ok
auto functionIsFunc = is_func<std::function<int()>>; //false -- wrong
auto lambdaIsFunc = is_func<decltype(lambda)>; //false -- wrong
What is wrong with the code?
How to improve the is_func to return true not only on callable objects, but callable with return type which is constructible (use somewhere std::is_constructible_v<>)?

Answer 1

Use enable_if
template <typename T, typename = void>
struct is_callable_non_void_return : public std::false_type {};
template <typename T>
struct is_callable_non_void_return<
T,
std::enable_if_t<!std::is_same_v<void, std::result_of_t<T()>>>>
: public std::true_type {};
This works because of SFINAE: Substitution Failure Is Not An Error.
The compiler will see the second is_callable_non_void_return as a specialization of the first, and try to match the template by instantiating the enable_if: first result_of_t, then is_same_v. If either fails, then a substitution failure occurs and the compiler falls back to the general case.

Answer 2

You misunderstand what template specialization means.
template<class T, class U = T>
struct is_callable
this is the primary specialization.
When you do is_callable<Foo> it means you are typing is_callable<Foo, Foo>. Nothing you co in other specializations can change this.
template<class T>
struct is_callable<T, std::result_of_t<T()>>
this attemptes to match against the arguments passed, it never changes them.
So for is_callable<Foo> this is is_callable<Foo,Foo>. Matching T against Foo is easy; so now we have T=Foo. We then look at the ones that are dependent on T -- std::result_of_t<T()> aka std::result_of_t<Foo()>. This evaluates to the result of calling Foo with () (roughly).
If we had:
struct Foo {
Foo operator(){ return {}; }
};
then std::result_of_t<Foo()> is Foo, and the specialization matches!
But if we have Foo=std::function<void()> then the result of () is void coming out of std::result_of_t<Foo()>.
Thus we have is_callable<Foo, void> matching against is_callable<Foo, Foo>. This obviously doesn't match as Foo does not equal void.
template<class T, class U = void>
struct is_callable
// body unchanged
notice the U=void instead of the U=T.
template<class T>
struct is_callable<T, std::void_t<std::result_of_t<T()>>>
// body unchanged
and here we use void_t.
std::void_t takes any types passed to it and produces void. Now let us go through the same exercise with is_callable< std::function<int()> >.
Under the primary specialization this becomes
is_callable<std::function<int()>, void>
we then try to match it against the specialization:
template<class T>
struct is_callable<T, std::void_t<std::result_of_t<T()>>>
again, T=std::function<int()> arrives immediately. The second clause is in a dependent context, so we don't pattern match it.
struct is_callable<std::function<int()>, std::void_t<std::result_of_t<std::function<int()>()>>>
struct is_callable<std::function<int()>, std::void_t<int>>
struct is_callable<std::function<int()>, void>
and wow, this matches the types passed to the template!
std::enable_if uses a trick whereby if the first argument is true, it returns the second argument (defaulting to void). If the first argument is false, it is a substitution failure.
How to improve the is_func to return true not only on callable objects, but callable with return type which is constructible (use somewhere std::is_constructible_v<
I'll skip the bodies:
template<class T, class=void>
struct is_callable
// ...
template<class T>
struct is_callable<T, std::enable_if_t<
std::is_constructible_v< std::result_of_t<T()> >
>>
now, for a type T for which T() is not constructible, the specialization fails to match because in computing the 2nd argument we get a substitution failure. And when it is constructible, we get void.