C++17 - How to deduct the variadic parameter pack of a lambda passed as a template parameter?

Question

I have a class memoize which deducts the variadic argument list of a function pointer passed to it as a template parameter (see code below).

I would like to be able to do the same thing for a lambda, but I don't seem to find the right way to do it. Ideally it should work when uncommenting and completing the last line of the main() function below (or see on https://godbolt.org/z/Y8G47h4GK).

#include <tuple>
#include <iostream>

template<typename... Ts> struct pack { };

template <class> struct pack_helper;

template <class R, class... Args> 
struct pack_helper<R(Args...)> {
    using args = pack<Args...>;
};

template <class R, class... Args> 
struct pack_helper<R(*)(Args...)> {
    using args = pack<Args...>;
};

template <class F, class = typename pack_helper<F>::args> 
class memoize;

template <class F, class... Args>
class memoize<F, pack<Args...>>
{
public:
    using result_type = std::invoke_result_t<F, Args...>;

    memoize(F &&f) : _f(std::forward<F>(f)) {}

    result_type operator()(Args... args) { return _f(args...); }
private:
    F _f;
};

int test(int x) { return x + 1; }

int main() {
    auto test_mem = memoize<decltype(&test)>(&test);
    std::cout << test_mem(2) << '\n';

    auto l = [](int x) -> int { return x + 1; };
    // auto l_mem = memoize<?>(?);
}

Does [this](https://stackoverflow.com/questions/7943525/is-it-possible-to-figure-out-the-parameter-type-and-return-type-of-a-lambda) answer your question? — n. m. could be an AI, Mar 26 '22 at 20:37
yes, it helped putting me on the path to figure out my solution. Thanks @n.1.8e9-where's-my-sharem. ! — greg_p, Mar 26 '22 at 22:08

score 1 · Accepted Answer · answered Mar 26 '22 at 21:06

The following should do the trick. Note that the pack_helper logic has been modified, even for function pointers.

template<typename... Ts> struct pack { };


// helper functions to retrieve arguments for member function pointers

template<class Result, class Type, class ...Args>
pack<Args...> lambda_pack_helper(Result(Type::*) (Args...));

template<class Result, class Type, class ...Args>
pack<Args...> lambda_pack_helper(Result(Type::*) (Args...) const);

// helper functions: if called with an instance of the first parameter type of memorize, the return type is the one used as the second one

// overload for function
template<class Result, class ...Args>
pack<Args...> pack_helper(Result(Args...));

// overload for function pointer
template<class Result, class ...Args>
pack<Args...> pack_helper(Result (*)(Args...));

// sfinae will prevent this overload from being considered for anything not providing an operator()
// for those types we use the return type of helper function lambda_pack_helper
template<class T>
decltype(lambda_pack_helper(&T::operator())) pack_helper(T);


template <class F, class = decltype(pack_helper(std::declval<F>()))>
class memoize;

template <class F, class... Args>
class memoize<F, pack<Args...>>
{
public:
    using result_type = std::invoke_result_t<F, Args...>;

    memoize(F&& f) : _f(std::move(f)) {}

    memoize(F const& f) : _f(f) {}

    result_type operator()(Args... args) { return _f(args...); }
private:
    F _f;
};

int test(int x) { return x + 1; }

int main() {
    auto test_mem = memoize<decltype(&test)>(&test);
    std::cout << test_mem(2) << '\n';

    auto l = [](int x) -> int { return x + 1; };

    auto l_mem = memoize<decltype(l)>(l);
    std::cout << l_mem(3) << '\n';
}

greg_p · Answer 2 · 2022-03-26T21:58:43.250

I found another way (see below) but I think fabian's answer above is better!

#include <iostream>

template<typename... Ts> struct pack { };

template <class> struct pack_helper;

template <class R, class... Args> 
struct pack_helper<R(Args...)> {
    using args = pack<Args...>;
};

template <class R, class... Args> 
struct pack_helper<R(*)(Args...)> {
    using args = pack<Args...>;
};

// ---- for lambdas
template <class T> 
struct pack_helper : public pack_helper<decltype(&T::operator())>
{};

template <class LambdaClass, class R, class... Args> 
struct pack_helper<R(LambdaClass::*)(Args...) const> {
    using args = pack<Args...>;
};

template <class F, class =  typename pack_helper<F>::args>
class memoize;

template <class F, class... Args>
class memoize<F, pack<Args...>>
{
public:
    using result_type = decltype(std::declval<F>()(std::declval<Args>()...));

    memoize(F&& f) : _f(std::forward<F>(f)) {}

    memoize(F const& f) : _f(f) {}

    result_type operator()(Args... args) { return _f(args...); }
private:
    F _f;
};

int test(int x) { return x + 1; }

int main() {
    auto test_mem = memoize<decltype(&test)>(&test);
    std::cout << test_mem(2) << '\n';

    auto l = [](int x) -> int { return x + 1; };

    auto l_mem = memoize<decltype(l)>(l);
    std::cout << l_mem(3) << '\n';
}

C++17 - How to deduct the variadic parameter pack of a lambda passed as a template parameter?

2 Answers2