I have learned the basic difference between `foldLeft` and `reduceLeft`

**foldLeft:**

 - initial value has to be passed

**reduceLeft:**

 - takes first element of the collection as initial value
 - throws exception if collection is empty

Is there any other difference ?

Any specific reason to have two methods with similar functionality?

difference between foldLeft and reduceLeft in Scala

When should I use `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`, `scanLeft` or `scanRight`?

I want an intuition/overview of their differences - possibly with some simple examples.

Reduce, fold or scan (Left/Right)?

I am pretty confused with both functions `fold()` and `reduce()` in Kotlin, can anyone give me a concrete example that distinguishes both of them? 

Difference between fold and reduce in Kotlin, When to use which?

Firstly, *Real World Haskell*, which I am reading, says to never use `foldl` and instead use `foldl&#39;`. So I trust it.  

But I&#39;m hazy on when to use `foldr` vs. `foldl&#39;`. Though I can see the structure of how they work differently laid out in front of me, I&#39;m too stupid to understand when &quot;which is better.&quot; I guess it seems to me like it shouldn&#39;t really matter which is used, as they both produce the same answer (don&#39;t they?). In fact, my previous experience with this construct is from Ruby&#39;s `inject` and Clojure&#39;s `reduce`, which don&#39;t seem to have &quot;left&quot; and &quot;right&quot; versions. (Side question: which version do they use?)  

Any insight that can help a smarts-challenged sort like me would be much appreciated!



Implications of foldr vs. foldl (or foldl&#39;)

What is the most idiomatic way to achieve something like the following, in Haskell:

    foldl (+) 0 [1,2,3,4,5]
    --&gt; 15

Or its equivalent in Ruby:

    [1,2,3,4,5].inject(0) {|m,x| m + x}
    #&gt; 15

Obviously, Python provides the `reduce` function, which is an implementation of fold, exactly as above, however, I was told that the &#39;pythonic&#39; way of programming was to avoid `lambda` terms and higher-order functions, preferring list-comprehensions where possible. Therefore, is there a preferred way of folding a list, or list-like structure in Python that isn&#39;t the `reduce` function, or is `reduce` the idiomatic way of achieving this?



What is the &#39;pythonic&#39; equivalent to the &#39;fold&#39; function from functional programming?

The code for the myAny function in &lt;a href=&quot;https://stackoverflow.com/questions/833186/why-does-this-haskell-code-work-successfully-with-infinite-lists/833218&quot;&gt;this question&lt;/a&gt; uses foldr.  It stops processing an infinite list when the predicate is satisfied.

I rewrote it using foldl:

&lt;pre&gt;&lt;code&gt;myAny :: (a -&gt; Bool) -&gt; [a] -&gt; Bool
myAny p list = foldl step False list
   where
      step acc item = p item || acc&lt;/code&gt;&lt;/pre&gt;

(Note that the arguments to the step function are correctly reversed.)

However, it no longer stops processing infinite lists.

I attempted to trace the function&#39;s execution as in &lt;a href=&quot;https://stackoverflow.com/questions/833186/why-does-this-haskell-code-work-successfully-with-infinite-lists/833218#833218&quot;&gt;Apocalisp&#39;s answer&lt;/a&gt;:

&lt;pre&gt;&lt;code&gt;myAny even [1..]
foldl step False [1..]
step (foldl step False [2..]) 1
even 1 || (foldl step False [2..])
False  || (foldl step False [2..])
foldl step False [2..]
step (foldl step False [3..]) 2
even 2 || (foldl step False [3..])
True   || (foldl step False [3..])
True&lt;/code&gt;&lt;/pre&gt;

However, this is not the way the function behaves.  How is this wrong?

foldl versus foldr behavior with infinite lists

Trying to learn F# but got confused when trying to distinguish between [fold][1] and [reduce][2]. Fold seems to do the [same thing][3] but takes an extra parameter. Is there a legitimate reason for these two functions to exist or they are there to accommodate people with different backgrounds? (E.g.: String and string in C#)

Here is code snippet copied from sample:

    let sumAList list =
        List.reduce (fun acc elem -&gt; acc + elem) list

    let sumAFoldingList list =
        List.fold (fun acc elem -&gt; acc + elem) 0 list

    printfn &quot;Are these two the same? %A &quot; 
                 (sumAList [2; 4; 10] = sumAFoldingList [2; 4; 10])

  [1]: http://msdn.microsoft.com/en-us/library/ee353894.aspx
  [2]: http://msdn.microsoft.com/en-us/library/ee370239.aspx
  [3]: https://stackoverflow.com/questions/3682371/accumulate-vs-fold-vs-reduce-vs-compress

Difference between fold and reduce?

I&#39;m aware that fold-left produces left-leaning trees and fold-right produces right-leaning trees, but when I reach for a fold, I sometimes find myself getting bogged down in headache-inducing thought trying to determine which kind of fold is appropriate.  I usually end up unwinding the entire problem and stepping through the implementation of the fold function as it applies to my problem. 

So what I want to know is:

 - What are some rules of thumb for determining whether to fold left or fold right?
 - How can I quickly decide which type of fold to use given the problem I&#39;m facing?

There is an example in [Scala by Example][1] (PDF) of using a fold to write a function called flatten which concatenates a list of element lists into a single list.  In that case, a right fold is the proper choice (given the way the lists are concatenated), but I had to think about it a bit to arrive at that conclusion.

Since folding is such a common action in (functional) programming, I&#39;d like to be able to make these kinds of decisions quickly and confidently.  So... any tips?


  [1]: http://www.scala-lang.org/docu/files/ScalaByExample.pdf

How do you know when to use fold-left and when to use fold-right?

Why do Scala and frameworks like Spark and Scalding have both `reduce` and `foldLeft`? So then what&#39;s the difference between `reduce` and `fold`?

Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?

Can anybody explain how does [`foldr`][1] work?

Take these examples:

    Prelude&gt; foldr (-) 54 [10, 11]
    53
    Prelude&gt; foldr (\x y -&gt; (x+y)/2) 54 [12, 4, 10, 6]
    12.0

I am confused about these executions. Any suggestions?

[1]: http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:foldr

How does foldr work?

I wanted to test foldl vs foldr. From what I&#39;ve seen you should use foldl over foldr when ever you can due to tail reccursion optimization.

This makes sense. However, after running this test I am confused:

foldr (takes 0.057s when using time command):

    a::a -&gt; [a] -&gt; [a]
    a x = ([x] ++ )
    
    main = putStrLn(show ( sum (foldr a [] [0.. 100000])))

    
foldl (takes 0.089s when using time command):

    b::[b] -&gt; b -&gt; [b]
    b xs = ( ++ xs). (\y-&gt;[y])
    
    main = putStrLn(show ( sum (foldl b [] [0.. 100000])))

It&#39;s clear that this example is trivial, but I am confused as to why foldr is beating foldl. Shouldn&#39;t this be a clear case where foldl wins?
    


foldl is tail recursive, so how come foldr runs faster than foldl?

In *[Real World Haskell][1]*, Chapter 4. on [Functional Programming][2]:

Write foldl with foldr:

    -- file: ch04/Fold.hs
    myFoldl :: (a -&gt; b -&gt; a) -&gt; a -&gt; [b] -&gt; a
    
    myFoldl f z xs = foldr step id xs z
        where step x g a = g (f a x)

The above code confused me a lot, and somebody called **dps** rewrote it with a meaningful name to make it a bit clearer:

    myFoldl stepL zeroL xs = (foldr stepR id xs) zeroL
    where stepR lastL accR accInitL = accR (stepL accInitL lastL)

Somebody else, Jef G, then did an excellent job by providing an example and showing the underlying mechanism step by step:

    myFoldl (+) 0 [1, 2, 3]
    = (foldR step id [1, 2, 3]) 0
    = (step 1 (step 2 (step 3 id))) 0
    = (step 1 (step 2 (\a3 -&gt; id ((+) a3 3)))) 0
    = (step 1 (\a2 -&gt; (\a3 -&gt; id ((+) a3 3)) ((+) a2 2))) 0
    = (\a1 -&gt; (\a2 -&gt; (\a3 -&gt; id ((+) a3 3)) ((+) a2 2)) ((+) a1 1)) 0
    = (\a1 -&gt; (\a2 -&gt; (\a3 -&gt; (+) a3 3) ((+) a2 2)) ((+) a1 1)) 0
    = (\a1 -&gt; (\a2 -&gt; (+) ((+) a2 2) 3) ((+) a1 1)) 0
    = (\a1 -&gt; (+) ((+) ((+) a1 1) 2) 3) 0
    = (+) ((+) ((+) 0 1) 2) 3
    = ((0 + 1) + 2) + 3

But I still cannot fully understand that, here are my questions:

 1. What is the id function for? What is the role of? Why should we need it here?
 2. In the above example, id function is the accumulator in the lambda function?
 3. foldr&#39;s prototype is `foldr :: (a -&gt; b -&gt; b) -&gt; b -&gt; [a] -&gt; b`, and the first parameter is a function which need two parameters, but the step function in the myFoldl&#39;s implementation uses 3 parameters, I&#39;m complelely confused!

  [1]: http://book.realworldhaskell.org/read/index.html
  [2]: http://book.realworldhaskell.org/read/functional-programming.html

Writing foldl using foldr

I have issues with the following passage from [Learn You A Haskell][1] (Great book imo, not dissing it):

&gt; One big difference is that right
&gt; folds work on infinite lists, whereas left ones don&#39;t! To put it
&gt; plainly, if you take an infinite list at some point and you fold it up
&gt; from the right, you&#39;ll eventually reach the beginning of the list.
&gt; However, if you take an infinite list at a point and you try to fold
&gt; it up from the left, you&#39;ll never reach an end!

    
I just don&#39;t get this. If you take an infinite list and try to fold it up from the right then you&#39;ll have to start at the point at infinity, which just isn&#39;t happening (If anyone knows of a language where you can do this do tell :p). At least, you&#39;d have to start there according to Haskell&#39;s implementation because in Haskell foldr and foldl don&#39;t take an argument that determines where in the list they should start folding.

I would agree with the quote iff foldr and foldl took arguments that determined where in the list they should start folding, because it makes sense that if you take an infinite list and start folding right from a defined index it *will* eventually terminate, whereas it doesn&#39;t matter where you start with a left fold; you&#39;ll be folding towards infinity. However foldr and foldl *do not* take this argument, and hence the quote makes no sense. In Haskell, both a left fold and a right fold over an infinite list **will not terminate**.

Is my understanding correct or am I missing something?


  [1]: http://learnyouahaskell.com/higher-order-functions#folds

Left and Right Folding over an Infinite list

Is there some plugin to fold HTML tags in Vim? &lt;br&gt;
Or there is another way to setup a shortcut to fold or unfold html tags? &lt;br&gt;
I would like to fold/unfold html tags just like I do with indentation folding.

How to fold/unfold HTML tags with Vim

NOTE: I am on Scala 2.8—can that be a problem?

Why can&#39;t I use the `fold` function the same way as `foldLeft` or `foldRight`?

In the [Set scaladoc][1] it says that:

&gt; The result of folding may only be a supertype of this parallel collection&#39;s type parameter `T`.

But I see no type parameter `T` in the function signature:

    def fold [A1 &gt;: A] (z: A1)(op: (A1, A1) ⇒ A1): A1

What is the difference between the `foldLeft-Right` and `fold`, and how do I use the latter?

EDIT: For example how would I write a fold to add all elements in a list? With `foldLeft` it would be:
 
    val foo = List(1, 2, 3)
    foo.foldLeft(0)(_ + _)

    // now try fold:
    foo.fold(0)(_ + _)
    &gt;:7: error: value fold is not a member of List[Int]
      foo.fold(0)(_ + _)
        ^


  
  [1]: http://www.scala-lang.org/api/current/scala/collection/immutable/Set.html

Difference between fold and foldLeft or foldRight?

Is difference between `foldl` and `foldr` just the direction of looping? I thought there was a difference in what they did, not just in the direction?

Haskell - foldl and foldr?

Consider a single-linked list. It looks something like

    data List x = Node x (List x) | End

It is natural to define a folding function such as

    reduce :: (x -&gt; y -&gt; y) -&gt; y -&gt; List x -&gt; y

In a sense, `reduce f x0` replaces every `Node` with `f` and every `End` with `x0`. This is what the Prelude refers to as a _fold_.

Now consider a simple binary tree:

    data Tree x = Leaf x | Branch (Tree x) (Tree x)

It is similarly natural to define a function such as

    reduce :: (y -&gt; y -&gt; y) -&gt; (x -&gt; y) -&gt; Tree x -&gt; y

Notice that _this_ reduction has a quite different character; whereas the list-based one is inherently sequential, this new tree-based one has more of a divide-and-conquer feel to it. You could even imagine throwing a few `par` combinators in there. (Where would you put such a thing in the list version?)

My question: Is this function still classified as a &quot;fold&quot;, or is it something else? (And if so, what is it?)

Basically whenever anybody talks about folding, they always talk about folding _lists_, which is inherently sequential. I&#39;m wondering whether &quot;sequential&quot; is part of the definition of what a fold is, or whether this is merely a coincidental property of the most commonly-used example of folding.


What constitutes a fold for types other than list?

A [`Foldable`][1] instance is likely to be some sort of container, and so is likely to be a `Functor` as well. Indeed, [this][2] says

&gt; A `Foldable` type is also a container (although the class does not technically require `Functor`, interesting `Foldable`s are all `Functor`s).

So is there an example of a `Foldable` which is not naturally a `Functor` or a `Traversable`? (which perhaps the Haskell wiki page missed :-) )


  [1]: http://hackage.haskell.org/packages/archive/base/latest/doc/html/Data-Foldable.html
  [2]: http://www.haskell.org/haskellwiki/Foldable_and_Traversable

An example of a Foldable which is not a Functor (or not Traversable)?

What are some good tutorials on fold left?

_Original question, restored from deletion to provide context for other answers:_

I am trying to implement a method for finding the boudning box of rectangle, circle, location and the group which all extends Shape. Group is basically an array of Shapes

    abstract class Shape  
    case class Rectangle(width: Int, height: Int) extends Shape  
    case class Location(x: Int, y: Int, shape: Shape) extends Shape  
    case class Circle(radius: Int) extends Shape  
    case class Group(shape: Shape*) extends Shape  

I got the bounding box computed for all three except the Group one. So now for the bounding box method I know I should be using map and fold left for Group, but I just can&#39;t find out the exact syntax of creating it.

    object BoundingBox {  
      def boundingBox(s: Shape): Location = s match {  
        case Circle(c)=&gt;   
          new Location(-c,-c,s)  
        case Rectangle(_, _) =&gt;  
          new Location(0, 0, s)  
        case Location(x, y, shape) =&gt; {  
          val b = boundingBox(shape)  
          Location(x + b.x, y + b.y, b.shape)  
        }  
        case Group(shapes @ _*) =&gt;  ( /: shapes) { } // i dont know how to proceed here.
      }
    }

Group bounding box is basically the smallest bounding box with all the shapes enclosed.


Functional programming, Scala map and fold left

I am trying to understand how fold and foldLeft and the respective reduce and reduceLeft work. I used fold and foldLeft as my example

    scala&gt; val r = List((ArrayBuffer(1, 2, 3, 4),10))
    scala&gt; r.foldLeft(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    
    scala&gt; res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5)
    
    scala&gt; r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    &lt;console&gt;:11: error: value _1 is not a member of Serializable with Equals
                  r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
       
Why `fold` didn&#39;t work as `foldLeft`? What is `Serializable with Equals`? I understand fold and foldLeft has slight different API signature in terms of parameter generic types. Please advise. Thanks.

All Fold Solutions on Gang of Coders

Total of 20 Fold Solutions