fold vs reduce argument order about list HOT 2 CLOSED

first, I just wanted to congradulate you on some very impressive work!

Thank you. Comments like that mean a lot 😄

I definitely agree that having the accumulator last is better when composing functions.

I realize that the documentation is quite poor in this regard, but in List foldr gives the accumulator last and foldl gives the accumulator first. That is the order used often in functional programming and I think it makes sense. The explanation I've read is to think of foldr as inserting the function between the elements in the list in a right-associative manner and then foldl doing that left-associative. This example shows what I mean.

const f = (n, m) => n - m;
foldr(f, 0, list(1, 2, 3, 4)); //=> f(1, f(2, f(3, f(4, 0)))) = (1 - (2 - (3 - (4 - 0))))
foldl(f, 0, list(1, 2, 3, 4)); //=> f(f(f(f(0, 1), 2), 3), 4) = ((((0 - 1) - 2) - 3) - 4)

In the foldr case the accumulator "naturally" appears as the second argument to the function and for foldl it is first.

The reduce function in Fantasy Land and Ramda gives the accumulator first which is ok as they are left folds. The reduceRight function in Ramda gives the accumulator as the second argument which is also great.

I think that in functional programming foldr should be the default fold. This is in contrast to JavaScript where the left folding reduce is the default fold people use. That is a big part of the reason why List prefers the names foldr and foldl instead of reduce and reduceRight.

What I'm trying to say is: List is currently consistent with Haskell and Ramda and I recommend using foldr which gives the nice argument order 😄

What do you think about that?

from list.

As explained above I think List's foldr/reduceRight and foldl/reduce is consistent with both typical FP conventions and Ramda in particular. So I'm going to close this issue. Feel free to open it @wishfoundry if you disagree 😄

from list.