Можно ли выяснить тип параметра и тип возврата лямбда?

Question

Учитывая лямбду, возможно ли выяснить ее тип параметра и тип возвращаемого значения?Если да, то как?

По сути, я хочу lambda_traits, который можно использовать следующими способами:

auto lambda = [](int i) { return long(i*10); };

lambda_traits<decltype(lambda)>::param_type  i; //i should be int
lambda_traits<decltype(lambda)>::return_type l; //l should be long

Мотивация заключается в том, что я хочу использовать lambda_traits в функциишаблон, который принимает лямбду в качестве аргумента, и мне нужно знать, что это тип параметра и тип возвращаемого значения внутри функции:

template<typename TLambda>
void f(TLambda lambda)
{
   typedef typename lambda_traits<TLambda>::param_type  P;
   typedef typename lambda_traits<TLambda>::return_type R;

   std::function<R(P)> fun = lambda; //I want to do this!
   //...
}

В настоящее время мы можем предположить, что лямбда принимает ровно один аргумент.

Первоначально я пытался работать с std::function как:

template<typename T>
A<T> f(std::function<bool(T)> fun)
{
   return A<T>(fun);
}

f([](int){return true;}); //error

Но, очевидно, это дало бы ошибку.Поэтому я изменил его на TLambda версию шаблона функции и хочу создать объект std::function внутри функции (как показано выше).

Answer 1

Забавно, я только что написал function_traits реализацию на основе , специализирующую шаблон для лямбды в C ++ 0x , который может дать Типы параметров. Хитрость, как описано в ответе на этот вопрос, заключается в использовании decltype из лямбды operator().

template <typename T>
struct function_traits
    : public function_traits<decltype(&T::operator())>
{};
// For generic types, directly use the result of the signature of its 'operator()'

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) const>
// we specialize for pointers to member function
{
    enum { arity = sizeof...(Args) };
    // arity is the number of arguments.

    typedef ReturnType result_type;

    template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
        // the i-th argument is equivalent to the i-th tuple element of a tuple
        // composed of those arguments.
    };
};

// test code below:
int main()
{
    auto lambda = [](int i) { return long(i*10); };

    typedef function_traits<decltype(lambda)> traits;

    static_assert(std::is_same<long, traits::result_type>::value, "err");
    static_assert(std::is_same<int, traits::arg<0>::type>::value, "err");

    return 0;
}

Обратите внимание, что это решение не работает для общей лямбды, такой как [](auto x) {}.

Answer 2

Хотя я не уверен, что это строго стандартное соответствие, ideone скомпилировал следующий код:

template< class > struct mem_type;

template< class C, class T > struct mem_type< T C::* > {
  typedef T type;
};

template< class T > struct lambda_func_type {
  typedef typename mem_type< decltype( &T::operator() ) >::type type;
};

int main() {
  auto l = [](int i) { return long(i); };
  typedef lambda_func_type< decltype(l) >::type T;
  static_assert( std::is_same< T, long( int )const >::value, "" );
}

Однако, это обеспечивает только тип функции, поэтому результат и параметр типы должны быть извлечены из него. Если вы можете использовать boost::function_traits, result_type и arg1_type встретит цель. Так как ideone, похоже, не обеспечивает повышение в режиме C ++ 11, я не смог опубликовать фактический код, извините.

Answer 3

Метод специализации, показанный в ответе @KennyTMs, может быть расширен для охвата всех случаев, включая вариабельные и изменяемые лямбды:

template <typename T>
struct closure_traits : closure_traits<decltype(&T::operator())> {};

#define REM_CTOR(...) __VA_ARGS__
#define SPEC(cv, var, is_var)                                              \
template <typename C, typename R, typename... Args>                        \
struct closure_traits<R (C::*) (Args... REM_CTOR var) cv>                  \
{                                                                          \
    using arity = std::integral_constant<std::size_t, sizeof...(Args) >;   \
    using is_variadic = std::integral_constant<bool, is_var>;              \
    using is_const    = std::is_const<int cv>;                             \
                                                                           \
    using result_type = R;                                                 \
                                                                           \
    template <std::size_t i>                                               \
    using arg = typename std::tuple_element<i, std::tuple<Args...>>::type; \
};

SPEC(const, (,...), 1)
SPEC(const, (), 0)
SPEC(, (,...), 1)
SPEC(, (), 0)

Демо .

Обратите внимание, что арность не корректируется для переменных operator() с.Вместо этого можно также рассмотреть is_variadic.

Answer 4

Ответ, предоставленный @KennyTMs, прекрасно работает, однако, если у лямбды нет параметров, использование индекса arg <0> не компилируется.Если у кого-то еще была эта проблема, у меня есть простое решение (проще, чем использование решений, связанных с SFINAE, то есть).

Просто добавьте void в конец кортежа в структуре arg после переменных типов аргументов.то есть

template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...,void>>::type type;
    };

, поскольку арность не зависит от фактического числа параметров шаблона, фактическое значение не будет неправильным, и если оно равно 0, то по крайней мере аргумент <0> все еще будет существовать, и выДелай с этим что хочешь.Если вы уже планируете не превышать индекс arg<arity-1>, это не должно мешать вашей текущей реализации.