Why std::is_function returns false for simple functions and lambdas?

Question

Having the following piece of code:

#include <iostream>
#include <type_traits>

template <typename F,
          typename = typename std::enable_if<
                                              std::is_function< F >::value
                                            >::type>
int fun( F f ) // line 8
{
  return f(3);
}

int l7(int x)
{
  return x%7;
}

int main()
{
  auto l = [](int x) -> int{
    return x%7;
  };
  fun(l);  // line 23
  //fun(l7); this will also fail even though l7 is a regular function

  std::cout << std::is_function<decltype(l7)>::value ; // prints 1
}

I will get the following error:

main2.cpp: In function ‘int main()’:
main2.cpp:23:8: error: no matching function for call to ‘fun(main()::<lambda(int)>&)’
   fun(l);
        ^
main2.cpp:8:5: note: candidate: template<class F, class> int fun(F)
 int fun( F f )
     ^
main2.cpp:8:5: note:   template argument deduction/substitution failed:
main2.cpp:5:11: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
           typename = typename std::enable_if<
           ^

When I comment out the std::enable_if template parameter then it compiles and runs just fine. Why?

Pinson

std::is_function only checks for function types, which doesn't include lambdas. Is there a reason you need to use SFINAE? If you really want to do the check, you could check that f(3) is well-formed, rather than checking if f is function-like – Nitroso

Looks like you are actually looking for something like std::is_callable which is available with C++17, but "may be implemented in terms of std::is_convertible and std::result_of" with pure C++11. – Olfactory

@Nitroso How would you check if f(3) is well formed? – Pinson

@Pinson Something like this. This is expression SFINAE. – Nitroso

Answer 1

From cppreference:

Checks whether T is a function type. Types like std::function, lambdas, classes with overloaded operator() and pointers to functions don't count as function types.

This answer explains that you also need to use std::remove_pointer<F>::type as the type since functions are converted to pointers to functions when passing by value. So your code should look like this:

template <typename F,
          typename = typename std::enable_if<
                                              std::is_function<
                                                typename std::remove_pointer<F>::type
                                              >::value
                                            >::type>
int fun( F f )
{
  return f(3);
}

Whiplash

So at least f(l7) should work, right? Since l7 is a regular function – Pinson

Correct, and from your code you already see the right output for std::is_function<decltype(l7)> – Whiplash

You need a std::remove_pointer<F> as F is actually a pointer to the function. I'll update my answer – Whiplash

You're right. I've checked that with std::remove_pointer<F> but for lambda and not for function pointer. – Pinson

@Whiplash can functions be passed by reference? – Communitarian

@Nik-Lz Yes. void fun(void (&f)(int)); declares a function fun that takes a reference to a function f which takes an int and returns nothing. – Whiplash

Answer 2

Another way to approach this problem is to write a more specific type trait. This one, for example, checks that the argument types are convertible and works for anything that's callable.

#include <iostream>
#include <type_traits>
#include <utility>
#include <string>

template<class T, class...Args>
struct is_callable
{
    template<class U> static auto test(U*p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());

    template<class U> static auto test(...) -> decltype(std::false_type());

    static constexpr auto value = decltype(test<T>(nullptr))::value;
};

template<class T, class...Args>
static constexpr auto CallableWith = is_callable<T, Args...>::value;


template <typename F,
std::enable_if_t<
CallableWith<F, int>
>* = nullptr
>
int fun( F f ) // line 8
{
    return f(3);
}

int l7(int x)
{
    return x%7;
}

int main()
{
    auto l = [](int x) -> int{
        return x%7;
    };

    std::cout << "fun(l) returns " << fun(l) << std::endl;

    std::cout << CallableWith<decltype(l7), int> << std::endl;    // prints 1
    std::cout << CallableWith<decltype(l7), float> << std::endl;  // prints 1 because float converts to int
    std::cout << CallableWith<decltype(l7), const std::string&> << std::endl; // prints 0
}

Rowles

Answer 3

Have a look at std::is_invocable which also covers lambdas in C++17 (std::is_callable does not exist).

Dunnite