Can we get the type of a lambda argument?

by

It’s not desirable in the general case. (Note that it’s quite easy for std::function<T(A)> to specify what e.g. argument_type is: it’s just A! It’s available in the type definition.)

It would be possible to require each and every function object type to specify its argument types, and in turn mandate that the closure types generated from lambda expression do so. In fact, pre-C++0x features like adaptable functors would only work for such types.

However, we’re moving from that with C++0x and for good reasons. The simplest of which is simply overloading: a functor type with a templated operator() (a.k.a a polymorphic functor) simply takes all kind of arguments; so what should argument_type be? Another reason is that generic code (usually) attempts to specify the least constraints on the types and objects it operates on in order to more easily be (re)used.

In other words, generic code is not really interested that given Functor f, typename Functor::argument be int. It’s much more interesting to know that f(0) is an acceptable expression. For this C++0x gives tools such as decltype and std::declval (conveniently packaging the two inside std::result_of).

The way I see it you have two choices: require that all functors passed to your template use a C++03-style convention of specifying an argument_type and the like; use the technique below; or redesign. I’d recommend the last option but it’s your call since I don’t know what your codebase looks like or what your requirements are.

For a monomorphic functor type (i.e. no overloading), it is possible to inspect the operator() member. This works for the closure types of lambda expressions.

So we declare these helpers

template<typename F, typename Ret, typename A, typename... Rest>
A
helper(Ret (F::*)(A, Rest...));

template<typename F, typename Ret, typename A, typename... Rest>
A
helper(Ret (F::*)(A, Rest...) const);

// volatile or lvalue/rvalue *this not required for lambdas (phew)

that accept a pointer to member function taking at least one argument. And now:

template<typename F>
struct first_argument {
    typedef decltype( helper(&F::operator()) ) type;
};

[ an elaborate trait could successively query the lvalue-rvalue/const/volatile overloads and expose the first argument if it’s the same for all overloads, or use std::common_type.]

More Related Contents:

  1. Using member variable in lambda capture list inside a member function
  2. Using data member in lambda capture list inside a member function
  3. Declaring lambda with int type not working [closed]
  4. C++ lambda with captures as a function pointer
  5. Move capture in lambda
  6. Passing capturing lambda as function pointer
  7. What is the type of lambda when deduced with “auto” in C++11?
  8. How is std::function implemented?
  9. Bind Vs Lambda?
  10. C++0x lambda capture by value always const?
  11. C++11 lambda implementation and memory model
  12. Can lambda functions be templated?
  13. Lambda capture as const reference?
  14. Lifetime of lambda objects in relation to function pointer conversion
  15. Why can’t I capture this by-reference (‘&this’) in lambda?
  16. Lambda expressions as class template parameters
  17. How to immediately invoke a C++ lambda?
  18. std::remove_if – lambda, not removing anything from the collection
  19. Lambda functions as base classes
  20. How do static variables in lambda function objects work?
  21. Lambdas and capture by reference local variables : Accessing after the scope
  22. Are lambdas inlined like functions in C++?
  23. Should std::unique_ptr be permitted
  24. C++11 Change `auto` Lambda to a different Lambda?
  25. how to specify vc11 lambda calling convention
  26. Proper way to receive a lambda as parameter by reference
  27. When to use functors over lambdas
  28. Why can’t C++11 move a noncopyable functor to a std::function?
  29. Using Boost adaptors with C++11 lambdas
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment