fold

Haskell newb here I'm working on this problem in haskell: (**) Eliminate consecutive duplicates of list elements. If a list contains repeated elements they should be replaced with a single copy of the element. The order of the elements should not be changed. Example: * (compress '(a a a a b c c a a d e e e e)) (A B C A D E) The solution (which I had to look up) uses foldr: compress' :: (Eq a) => [a] -> [a] compress' xs = foldr (\x acc -> if x == (head acc) then acc else x:acc) [last xs] xs This foldr, according to the solution, takes two parameters, x and acc. It would seem like all foldr's

Foldable is a superclass of Traversable , similarly to how Functor is a superclass of Applicative and Monad . Similar to the case of Monad , where it is possible to basically implement fmap as liftM :: Monad m => (a->b) -> m a -> m b liftM f q = return . f =<< q we could also emulate foldMap as foldLiftT :: (Traversable t, Monoid m) => (a -> m) -> t a -> m foldLiftT f = fst . traverse (f >>> \x -> (x,x)) -- or: . sequenceA . fmap (f >>> \x -> (x, x)) using the Monoid m => (,) m monad. So the combination of superclass and methods bears in both cases a certain redundancy. In case of monads, it

I was reading through the paper A tutorial on the universality and expressiveness of fold , and am stuck on the section about generating tuples. After showing of how the normal definition of dropWhile cannot be defined in terms of fold, an example defining dropWhile using tuples was proved: dropWhile :: (a -> Bool) -> [a] -> [a] dropWhile p = fst . (dropWhilePair p) dropWhilePair :: (a -> Bool) -> [a] -> ([a], [a]) dropWhilePair p = foldr f v where f x (ys,xs) = (if p x then ys else x : xs, x : xs) v = ([], []) The paper states: In fact, this result is an instance of a general theorem

There are lots of good questions and answers about foldl , foldr , and foldl' in Haskell. So now I know that: 1) foldl is lazy 2) don't use foldl because it can blow up the stack 3) use foldl' instead because it is strict ( ish ) How foldl is evaluated: 1) a whole bunch of thunks are created 2) after Haskell is done creating thunks, the thunks are reduced 3) overflow the stack if there are too many thunks What I'm confused about: 1) why does reduction have to occur after all thunk-ing? 2) why isn't foldl evaluated just like foldl' ? Is this just an implementation side-effect? 3) from the

Can someone provide some examples for how /: :\ and /:\ Actually get used? I assume they're shortcuts to the reduce / fold methods, but there's no examples on how they actually get used in the Scala docs, and they're impossible to google / search for on StackOverflow. /: is a synonym for foldLeft and :\ for foldRight . But remember that : makes /: apply to the object to the right of it. Assuming you know that (_ * _) is an anonymous function that's equivalent to (a, b) => a * b , and the signature of foldLeft and foldRight are def foldLeft [B] (z: B)(f: (B, A) ⇒ B): B def foldRight [B] (z: B)

Haskell has two left fold functions for lists: foldl , and a "strict" version, foldl' . The problem with the non-strict foldl is that it builds a tower of thunks: foldl (+) 0 [1..5] --> ((((0 + 1) + 2) + 3) + 4) + 5 --> 15 This wastes memory, and may cause a stack overflow if the list has too many items. foldl' , on the other hand, forces the accumulator on every item. However, as far as I can tell, foldl' is semantically equivalent to foldl . Evaluating foldl (+) 0 [1..5] to head normal form requires forcing the accumulator at some point. If we didn't need a head-normal form, we wouldn't be