Inferring the call signature of a lambda or arbitrary callable for “make_function”

by

I’ve come up with a fairly nasty non-library solution, using the fact that lambdas have operator():

template<typename T> struct remove_class { };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...)> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) volatile> { using type = R(A...); };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const volatile> { using type = R(A...); };

template<typename T>
struct get_signature_impl { using type = typename remove_class<
    decltype(&std::remove_reference<T>::type::operator())>::type; };
template<typename R, typename... A>
struct get_signature_impl<R(A...)> { using type = R(A...); };
template<typename R, typename... A>
struct get_signature_impl<R(&)(A...)> { using type = R(A...); };
template<typename R, typename... A>
struct get_signature_impl<R(*)(A...)> { using type = R(A...); };
template<typename T> using get_signature = typename get_signature_impl<T>::type;

template<typename F> using make_function_type = std::function<get_signature<F>>;
template<typename F> make_function_type<F> make_function(F &&f) {
    return make_function_type<F>(std::forward<F>(f)); }

Any ideas where this can be simplified or improved? Any obvious bugs?

More Related Contents:

  1. Declaring lambda with int type not working [closed]
  2. How to convert a lambda to an std::function using templates
  3. Function returning a lambda expression
  4. Why can’t C++11 move a noncopyable functor to a std::function?
  5. Optimization code for a debug function (c++11 with templates) [closed]
  6. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  7. C++11 does not deduce type when std::function or lambda functions are involved
  8. How much is too much with C++11 auto keyword?
  9. Why does C++11’s lambda require “mutable” keyword for capture-by-value, by default?
  10. How to capture a unique_ptr into a lambda expression?
  11. Should I use std::function or a function pointer in C++?
  12. Is constexpr supported with lambda functions / expressions?
  13. The simplest and neatest c++11 ScopeGuard
  14. Using member variable in lambda capture list inside a member function
  15. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  16. Is it possible to std::move objects out of functions? (C++11)
  17. Capturing perfectly-forwarded variable in lambda
  18. I cannot pass lambda as std::function
  19. C++11 “overloaded lambda” with variadic template and variable capture
  20. `auto` specifier type deduction for references
  21. Can lambda functions be recursive? [duplicate]
  22. What is the lifetime of a C++ lambda expression?
  23. Why the initializer of std::function has to be CopyConstructible?
  24. Are lambdas inlined like functions in C++?
  25. C++11 Change `auto` Lambda to a different Lambda?
  26. how to specify vc11 lambda calling convention
  27. Proper way to receive a lambda as parameter by reference
  28. When to use functors over lambdas
  29. Using Boost adaptors with C++11 lambdas
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment