Question

I’ve a function that works well for me:

template <typename __container, typename __callback = std::function <
    void (typename __container::value_type, typename __container::value_type)>
>
int reduce(__container &&container, __callback &&callback)
{
    auto current = container.begin();

    for (auto value : container)
        *current = callback(*current, value);

    return *current;
};


int result = functional::reduce(vector, [](const int current, const int next) -> int {
    return current + next;
});

std::cout << result; // 10

And now, I’m going to unify the one:

template <typename __container, typename __callback = std::function <
    void (typename __container::value_type, typename __container::value_type)>
>
auto reduce(__container &&container, __callback &&callback) ->
 decltype(__container::value_type);

However I am getting the following error:

reduce.cpp:61:9: error: no matching function for call to 'reduce'
int i = reduce(vector, [](const int current, const int next) -> int {
        ^~~~~~~~~~~~~~~~~~
reduce.hpp:69:7: note: candidate template ignored: substitution failure [with __container = std::__1::list<int, std::__1::allocator<int>> &, __callback = <lambda at
      nott.cpp:61:36>]
        auto reduce(__container &&container, __callback &&callback) -> decltype(__container::value_type)
             ^
1 error generated.
make: *** [build] Error 1

How can I set the generic return type?

UPDATE:

template <typename __container, typename __callback>
auto reducef(const __container& input, __callback callback) ->
decltype(callback(std::declval<typename __container::value_type>(), std::declval<typename __container::value_type>()))
{
    decltype(
        callback(
            std::declval<typename __container::value_type>(),
            std::declval<typename __container::value_type>()
        )
    ) result{};

    return std::accumulate(input.begin(), input.end(), result, callback);
};

Answer 1

This signature is wrong:

auto reduce(__container &&container, __callback &&callback) ->
 decltype(__container::value_type);

value_type is a type and you decltype it. This is like decltype(int). However, __container::value_type won’t work either, since the compiler doesn’t know that value_type is a type. You have to make this explicit using typename:

auto reduce(__container &&container, __callback &&callback) ->
 typename __container::value_type;

There are some further things, that can be improved: You modify the front element of the compiler to reduce it. I think you want to do something like this:

auto current = *container.begin(); // added *

for (auto value : container)
    current = callback(*current, value); // removed *

return current; // removed *

There is yet another bug: the first value gets reduced twice.

assert(!container.empty());
auto current = *container.begin();

for (auto it=container.begin()+1; it!=container.end(); ++it)
    current = callback(current, *it);

return current;

Further improvement: Use iterators instead of ranges:

template <typename Iter, typename Callback>
T reduce(Iter start, Iter end, Callback&& F)
{
    assert(start != end);
    auto current = *start;
    while (++start != end)
      current = callback(current, *it);
    return *current;
};

Next question: Why the restriction of not accepting empty ranges? Use an initial value for that.

template <typename Iter, typename T, typename Callback>
T reduce(Iter start, Iter end, T init, Callback&& F)
{
    while (start != end)
      init = callback(init, *it++);
    return init;
};

And, surprise, this is exactly the definition of std::accumulate.