Writing a template function that evaluates a lambda function with any return type?

Question

I want to write an 'evaluation' function that takes as input a function of unspecified return type that takes an integer, and an integer to call that function with.

What I've come up with is the following:

#include <functional>
template<typename T>
T eval(function<T(int)> f, int x) {
    return f(x);
}

Let's say I have an auto func = [] (int x) -> long { return (long)x * x; } which I want to evaluate using the above function. The way I used template functions before was to simply call it as I would any other function and let the compiler deduce the type.

However, this doesn't work with this eval function. eval<long>(func, 5) compiles and works fine, however eval(func, 5) does not:

Aufgaben10.5.cpp:23:25: error: no matching function for call to 'eval(main()::__lambda0&, int)'
     cout << eval(func, 5) << endl;
                         ^
Aufgaben10.5.cpp:23:25: note: candidate is:
Aufgaben10.5.cpp:8:3: note: template<class T> T eval(std::function<T(int)>, int)
 T eval(function<T(int)> f, int x) {
   ^
Aufgaben10.5.cpp:8:3: note:   template argument deduction/substitution failed:
Aufgaben10.5.cpp:23:25: note:   'main()::__lambda0' is not derived from 'std::function<T(int)>'
     cout << eval(func, 5) << endl;

Is there a way to write a template function that has the same return type as the lambda function without explicitly passing the type to the template, so that I can simply call eval(func, 5)?

http://stackoverflow.com/questions/7943525/is-it-possible-to-figure-out-the-parameter-type-and-return-type-of-a-lambda — willj, Dec 16 '14 at 11:41
I'd get rid of `function` at all here, pass `T&& f` to the `eval`, and `decltype` the return type. — Bartek Banachewicz, Dec 16 '14 at 11:41

ForEveR · Accepted Answer · 2014-12-17T07:43:40.367

8

Why not use decltype?

template<typename Function>
auto eval(Function&& f, int x) -> decltype(std::forward<Function>(f)(x))
{
   return std::forward<Function>(f)(x);
}

edited Dec 17 '14 at 07:43

answered Dec 16 '14 at 11:41

ForEveR

55,233
2
119
133

2

I'd take `Function` by `&&`. Otherwise yeah, that, +1. – Bartek Banachewicz Dec 16 '14 at 11:42
Because I did not know about it. Thanks! :) – David Südholt Dec 16 '14 at 11:45
1

Not only needless; in case of noncopyable function objects it forbids the use at all. – Bartek Banachewicz Dec 16 '14 at 11:45
3

If you're going to take `Function` by `&&`, you should call it as `std::forward(f)(x)` in case it's ref qualified. – Barry Dec 16 '14 at 11:52
It's possible that the rvalue- and lvalue-qualified call operators of `f` return different types. The return type should really be `decltype(std::forward(f)(x))`. – Casey Dec 16 '14 at 20:06
Except that `F` is named `Function` here. :) Also, if C++14 is an option, `decltype(auto)` is another alternative. – Dec 16 '14 at 20:35

Writing a template function that evaluates a lambda function with any return type?

1 Answers1