Actually, #inject:into: is what is normally called fold or foldl,
and #reduce: is commonly called fold1.�� It is very confusing to
call foldl1 #fold:.
To the best of my knowledge, the name 'reduce' comes from APL.
"Z <- LO/R
��has the effect of placing the function LO between adjacent pairs
��of items along the last axis of R and evaluating the resulting
��expression for each subarray.
��If R is the vector A B C the LO-reduction is defined as follows:
��LO/R <-> A LO B LO C"
which for APL means A LO (B LO C), so it's technically foldr1.
-- IBM APL2 Language Reference, 1994, page 209.
The name given to #inject:into: when it was first invented was
LIT, short for List ITeration.
Here's a reference: Functional Programming, Application and
Implementation, Peter Henderson, 1980, page 41:
<quote>
As another example of a higher-order function consider the following
operation of reduction (the idea and the name are in fact taken from the
programming language APL). We define reduce(x,g,a) where x is a list,
g is a binary function, and a is a constant, so that the list
x = (Xl. . . Xk) is reduced to the value g(X1, g(X2, ... g(Xk,a) ...))
<snip>
reduce(x,g,a) = if x = NIL then a else
������������������������������ g(car(x),reduce(cdr(x),g,a))
</quote>
So APL used "reduce" for foldr1, and Henderson, because
most functions don't carry their identity with them,
used it for foldr.
As I recall it, the name "reduce" was dropped because
people wanted to support both foldl and foldr (and did
NOT want to apply it to higher-ranked arrays, so that
'rank reduced by 1' wasn't an aid to memory).�� But it
IS a name for the operation that predates Smalltalk
and is still in use (as APL itself is).
If it comes to that, this higher-order function is
called 'reduce' in Swift:
and of course the Map-Reduce paradigm is famous, and
guess what 'Reduce' stands for?
An intention-revealing name in Smalltalk would have been
�� aCollection injectInto: aBinaryValuable [ifNone: emptyBlock]