Why is a Redux reducer called a reducer?

The term “reduce” is actually a functional term used in functional programming. In a language like Haskell, F# or even JavaScript, we define a transformation that takes a collection (of any size) as input and returns a single value as output.

So (not to be pedantic, but I find this helps me) think of it visually. We have a collection:

[][][][][][][][][][]

…which we want to collapse into a single value:

N

Programming functionally, we would do this with a single function that we could call recursively on each element of the collection. But if you do that, you need to keep track of the intermediate value somewhere, right? Non-pure implementations might keep some kind of “accumulator” or variable outside of the function to keep track of the state, like so:

var accumulator = 0;
var myArray = [1,2,3,4,5];

myArray.reduce(function (each) {
    accumulator += 0;
});

return accumulator;

With pure functions, though, we can’t do this – because by definition, pure functions can’t have effects outside of their function scope. Instead of relying on an external variable that encapsulates our “state” between calls, we simply pass the state along in the method:

var myArray = [1,2,3,4,5];

return myArray.reduce(function (accumulator, each) {
    return accumulator + each;
}, 0);

In this case we call the function a “reducer” because of its method signature. We have each (or current – any name is fine), representing an object in the collection; and state (or previous), which is passed to each iteration of the function, representing the results of the transformation we’ve already done to the previous elements in the collection.

Note that the MDN documentation you referenced is correct; the reduce() function always does return a single value. In fact, the reduce method in any language is a higher-order function that takes a “reducer” (a function with the method signature defined above) and returns a single value. Now, yes, you can do other stuff with it, if your function that you call has side effects, but you shouldn’t. (Essentially, don’t use .reduce() as a foreach.) Even if the method you call with reduce has side effects, the return value of reduce itself will be a single value, not a collection.

The cool thing is, this pattern doesn’t just have to apply to arrays or concrete collections, as you’ve seen in React; this pattern can be applied to streams as well, since they’re pure functions.

Hope this helps. For what it’s worth, the definition on the Redux site could be improved (as the concept of a reducer isn’t just because of Javascript’s Array prototype method). You should submit a PR!

Edit: There’s a Wikipedia article on the subject. Note that reduce has different names, and in functional languages, it’s commonly known as Fold. https://en.wikipedia.org/wiki/Fold_(higher-order_function)#Folds_as_structural_transformations

Edit (2020-10-03): People still seem to be finding this useful – that’s good. With time, I’ve realized that “fold” is a much better term for this; the functional languages got it right. “Reducer” isn’t really a bad term, but it’s not necessarily a good one, either.