foldl1/foldr1 should use descriptive names as the '1' imparts no information

[OvermindDL1]

As requested by @jvoigtlaender this issue has been opened to propose changing the names (or at the very least aliasing the names to new names) of foldl1->reducel and foldr1->reducer or some variant there-of.

Immediate languages that come to mind that use this pattern are:

• F# (reduce == List.Extra.foldl1, fold == List.foldl):
  • Core: https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/list.reduce%5B't%5D-function-%5Bfsharp%5D
  • (As much as I am not a fan of Microsoft products, F# really is like a Haskell done better... although not as pure)
• CL (reduce == List.Extra.foldl1, reduce_from == List.foldl):
  • Core: http://clhs.lisp.se/Body/f_reduce.htm
  • Popular Emacs variant: https://github.com/magnars/dash.el
• Clojure (reduce == List.Extra.foldl1, fold == List.foldl):
  • Clojure is a language where the artity of a function is part of the function, thus it uses reduce for both the reduce and fold variants, depending on whether an accumulator was passed or not.
  • Core: https://clojuredocs.org/clojure.core.reducers/reduce
• Elixir (reduce == List.Extra.foldl1, foldl == List.foldl):
  • The List.foldl was a hold-over from erlang where Enum.reduce was added by Elixir itself, hence the different type signatures, they can both work over enumerables though once properly massaged.
  • However, Elixir is one of those languages like Clojure where the arity of a function is part of its name, thus Enum.reduce/2 and Enum.reduce/3 are both supplied, however Enum.reduce/3 delegates to List.foldl/3 in the majority of cases.
  • Core: http://elixir-lang.org/docs/stable/elixir/Enum.html#reduce/2
  • Core: http://elixir-lang.org/docs/stable/elixir/List.html#foldl/3
• Scala (reduceLeft == List.Extra.foldl1, foldLeft == List.foldl):
  • Core: http://www.scala-lang.org/api/2.11.8/index.html#scala.collection.immutable.List@foldLeft[B](z:B)(op:(B,A)=>B):B
  • Core: http://www.scala-lang.org/api/2.11.8/index.html#scala.collection.immutable.List@reduceLeft[B>:A](f:(B,A)=>B):B

And I just found a document on wikipedia: https://en.wikipedia.org/wiki/Fold_(higher-order_function)#Folds_in_various_languages

On the above wikipedia list Haskell is the only language that uses foldl1 and foldr1, the general usage among the rest of the languages are various usages of reduce such as reducel/reducer, reduce_l/reduce_r, reduce_l/reduce_r, reduce/reduce_r, reduce/reduce_right and so forth with them using either another variant of reduce or using foldl/foldr to handle the Elm List.foldl and List.foldr style functions.

As seen reduce is used almost exclusively in languages that have a reduce/fold?1 style function, and both reduce and fold are used fairly evenly for fold style functionality depending on whether the language has default currying (like F# and Elm languages are) or whether the arity is part of the function definition (like Clojure or Elixir).

Thus to maintain consistency with the rest of near the entire functional ecosystem List.Extra.foldl1 and List.Extra.foldr1 should be at most renamed or at least aliased with List.Extra.reducel and List.Extra.reducer or some variant there-of as it is both more descriptive and functional language standard.

[jvoigtlaender]

Just for the record: I didn't request opening this issue because I endorse the proposal, I just requested it so that important information is all together in an opening comment, not in a long (previous) discussion thread.

[Mouvedia]

It should probably be camelcased though.

reduceL / reduceR

@OvermindDL1 https://rosettacode.org/wiki/Catamorphism

[prikhi]

I like reduceL or reduceLeft