模板参数推导失败

Question

Even though it seems the call to fold_left in the following program is specific enough to deduce the templated function's argument, a compilation error arises due to a template argument deduction failure.

#include <valarray>
#include <functional>

template<class Input, class Output>
Output fold_left(Output zero, std::function<Output(Output,Input)> op, std::valarray<Input> data)
{
    for (auto const& item : data) {
        zero = op(zero, item);
    }
    return zero;
}

#include <iostream>
int main()
{
    std::valarray<int> data { 1, 2, 3, 4, 5 };
    std::cout << fold_left(0, std::plus<int>{}, data) << "\n";
}

 main.cpp: In function 'int main()': main.cpp:17:66: error: no matching function for call to 'fold_left(int, std::plus<int>, std::valarray<int>&)' std::cout << fold_left/*<int,int>*/(0, std::plus<int>{}, data) << "\\n"; ^ main.cpp:5:8: note: candidate: template<class Input, class Output> Output fold_left(Output, std::function<Output(Output, Input)>, std::valarray<_Tp>) Output fold_left(Output zero, std::function<Output(Output,Input)> op, std::valarray<Input> data) ^~~~~~~~~ main.cpp:5:8: note: template argument deduction/substitution failed: main.cpp:17:66: note: 'std::plus<int>' is not derived from 'std::function<Output(Output, Input)>' std::cout << fold_left/*<int,int>*/(0, std::plus<int>{}, data) << "\\n"; ^ 

This minimal program would only compile if fold_left is called with:

fold_left<int, int>(0, std::plus<int>{}, data);

This feels strange to me since the Output template argument should be obvious since we provided an int as the first argument ( zero ); similarly the Input template argument should be deduced correctly since we have provided an std::valarray<int> as the third argument ( data ) expecting a std::valarray<Input> .

The order of the arguments in the definition of fold_left are not relevant .

Why does template argument deduction fail here?

Answer 1

Because std::plus<int> is not an instance of std::function<O(O,I)> for some types O,I and they are in a deduced context there.

The solution is to replace std::function<O(O,I)> with a new template parameter that is itself just constrained based on the requirement that it is invocable with two arguments O,I and that the return type is convertible to O :

template<class Input, class Output, class F,
    std::enable_if_t<std::is_convertible_v<
        std::invoke_result_t<F&, Output, Input>,
        Output>, int> = 0>
Output fold_left(Output zero, F op, std::valarray<Input> data)
{ ... }

You could separately wrap the op argument in a non-deduced context, but you don't actually need the type erasure that std::function provides, so it's unnecssary.

Answer 2

This feels strange to me since the Output template argument should be obvious since we provided an int as the first argument

The compiler will try to resolve Output is in every location it is used. If the deduced types from different parameters don't match then you'll get an ambiguity which will cause the deduction to fail.

Since you use Output in Output zero and std::function<Output(Output,Input)> op the compiler is going to use 0 and std::plus<int> to try and figure out what Output is. std::plus<int> is not a std::function` so it can't figure out the type and that is why the substitution fails.

If you cast std::plus<int>{} into a std::function then the compiler can deduce the template types

std::cout << fold_left(0, std::function<int(int, int)>(std::plus<int>{}), data) << "\n";

If you don't want to have to do this though you will need to instead make the function a generic type and then use SFINAE to constrain the template like answer provided by Barry does.

Answer 3

The issue is that std::function<Output(Output,Input)> cannot properly deduce its template arguments, because std::plus<int> is not a std::function .

Type-deduction only works if the template types can match up with the arguments being passed; it doesn't perform transformations that would be done through conversions/constructions; but rather takes the type in totality.

In this case, std::plus<int> is not a std::function<int(int,int)> , it is convertible to a std::function<int(int,int)> . This is what is causing the deduction to fail.

The alternatives are to either break contributions to the type-deduction with an alias, to explicitly pass a std::function type, or to accept the function as a different template argument (which may actually be more efficient)

1. Break contribution to the type-deduction with an alias

If you make an alias of the type, so that the types don't contribute to the deduction, then it can leave the first and third arguments to determine the types of the std::function

(off the top of my head; untested)

template<typename T>
struct nodeduce{ using type = T; };

template<typename T>
using nodeduce_t = typename nodeduce<T>::type;

template<class Input, class Output>
Output fold_left(Output zero, std::function<nodeduce_t<Output>(nodeduce_t<Output>,nodeduce_t<Input>)> op, std::valarray<Input> data)
{
    ....
}

It's a bit of an ugly approach, but it will disable std::function from contributing to the deduction because the types are transformed through nodeduce_t .

2. Pass as std::function

This is the simplest approach; your calling code would become:

 fold_left(0, std::function<int(int,int)>(std::plus<int>{}), data);

Admittedly, it's not pretty -- but it would resolve the deduction because std::function<int(int,int)> can directly match the input.

3. Pass as template argument

This actually has some additional performance benefits; if you accept the argument as a template type, then it also allows your function to be inlined better by the compiler (something that std::function has issues with)

template<class Input, typename Fn, class Output>
Output fold_left(Output zero, Fn&& op, std::valarray<Input> data)
{
    for (auto const& item : data) {
        zero = op(zero, item);
    }
    return zero;
}

All of these are possible alternative that would accomplish the same task. It's also worth mentioning that compile-time validation can be done using SFINAE with things like enable_if or decltype evaluations:

template<class Input, typename Fn, class Output, typename = decltype( std::declval<Output> = std::declval<Fn>( std::declval<Output>, std::declval<Input> ), void())>
Output fold_left( ... ){ ... }

The decltype(...) syntax ensures the expression is well-formed, and if it is, then it allows this function to be used for overload resolution.

Edit : Updated the decltype evaluation to test Output and Input types. With C++17, you can also use std::is_convertible_v<std::invoke_result_t<F&, Output, Input>,Output> in an enable_if , as suggested by Barry in a different answer.