Template deduction fails for known argument

Question

Consider following code

template<typename T>
T modify(const T& item, std::function<T(const T&)> fn)
{
    return fn(item);
}

When trying to use it as modify(5, [](const int& i){return 10*i;}); it fails to compile with

could not deduce template argument for 'std::function<T(const T &)> from lambda

I know that compiler can not deduce T from lambda, because lambda is not std::function, but isn't T already deduced from 5?

I can get over it using

template<typename T, typename F>
T modify(const T& item, const F& functor)
{
    return functor(item);
}

for which previous example compiles, but it is in my opinion less intuitive. Is there a way to let the function argument to remain std::function and have it's template argument deduced automatically from item?

Using a separate template argument for the "predicate" is how the standard library does it. If you look at all [algorithmic functions in the standard library](http://en.cppreference.com/w/cpp/algorithm) you will see that all that takes a predicate takes it as a separate templated type. However all those functions are well specified and documented, making the "intuitive" point moot. Good documentation is the key here IMO. — Some programmer dude, Jul 12 '16 at 15:57
`std::function` is not an efficient solution when the functor type is known. Concepts will eventually solve the intuition problem. — Oktalist, Jul 12 '16 at 22:44

score 4 · Accepted Answer · answered Jul 12 '16 at 16:13

4

What you basically want to do is prevent deduction from happening. If template deduction occurs, it will fail (because a lambda is not a std::function<> - it doesn't matter that T was deduced from the first argument, deduction must succeed in every argument that is a deduced context). The way to prevent deduction is to stick the entire argument in a non-deduced context, the easiest way of doing that is to throw the type into a nested-name-specifier. We create such a type wrapper:

template <class T> struct non_deduce { using type = T; };
template <class T> using non_deduce_t = typename non_deduce<T>::type;

And then wrap the type in it:

template<typename T>
void foo(const T& item, std::function<void(T)> f);

template<typename T>
void bar(const T& item, non_deduce_t<std::function<void(T)>> f);

foo(4, [](int ){} ); // error
bar(4, [](int ){} ); // ok, we deduce T from item as int,
                     // which makes f of type std::function<void(int)>

Note, however, that:

template <typename T, typename F>
void quux(const T&, F );

is not really any less readable, and strictly more performant.

answered Jul 12 '16 at 16:13

Barry

286,269
29
621
977

I'd have made the "don't do it" warning even stronger, but +1. – T.C. Jul 12 '16 at 18:39
Why isn't `F` passed as `const F&` in `void quux(const T&, F );`? – Zereges Jul 13 '16 at 09:02
@Zereges Why would it be? – Barry Jul 13 '16 at 12:26
Consider calling `quux(5, foo)`, where `foo` is instance of functor with `operator()` and possibly some data, which would be copied if passed as value. Right? – Zereges Jul 13 '16 at 16:01
@Zereges Yes. What if `foo`'s `operator()` is non-`const`? I could see the argument for `F&&`, not for `F const&`. – Barry Jul 13 '16 at 16:02

score 3 · Answer 2 · answered Jul 12 '16 at 16:11

3

You can do it by using the identity trick as below:

template <typename T>
struct identity {
  typedef T type;
};

template<typename T>
T modify(const T& item, typename identity<std::function<T(const T&)>>::type fn) {
  return fn(item);
}

Live Demo

answered Jul 12 '16 at 16:11

101010

41,839
11
94
168

Template deduction fails for known argument

2 Answers2

Linked