fold

In Haskell, like in many other functional languages, the function foldl is defined such that, for example, foldl (-) 0 [1,2,3,4] = -10 . This is OK, because foldl (-) 0 [1, 2,3,4] is, by definition, ((((0 - 1) - 2) - 3) - 4) . But, in Racket, (foldl - 0 '(1 2 3 4)) is 2, because Racket "intelligently" calculates like this: (4 - (3 - (2 - (1 - 0)))) , which indeed is 2. Of course, if we define auxiliary function flip, like this: (define (flip bin-fn) (lambda (x y) (bin-fn y x))) then we could in Racket achieve the same behavior as in Haskell: instead of (foldl - 0 '(1 2 3 4)) we can write:

I'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'm facing? There is an example

Haskell addm::[Int]->Int addm (x:xs) = sum(x:xs) I was able to achieve to get a sum of a list using sum function but is it possible to get the sum of a list using map function? Also what the use of map function? You can't really use map to sum up a list, because map treats each list element independently from the others. You can use map for example to increment each value in a list like in map (+1) [1,2,3,4] -- gives [2,3,4,5] Another way to implement your addm would be to use foldl : addm' = foldl (+) 0 Here it is, the supposedly impossible definition of sum in terms of map : sum' xs = let {

I am a beginner at Haskell and learning from "Learn You a Haskell". There's something I don't understand about the Tree implementation of Foldable . instance F.Foldable Tree where foldMap f Empty = mempty foldMap f (Node x l r) = F.foldMap f l `mappend` f x `mappend` F.foldMap f r Quote from LYAH: "So if we just implement foldMap for some type, we get foldr and foldl on that type for free !" . Can someone explain this? I don't understand how and why do I get foldr and foldl for free now... foldr can always be defined as: foldr f z t = appEndo (foldMap (Endo . f) t) z where appEndo and Endo are