Data.Fold.Common.L'

A collection of common left folds. Note that all of these are strict and do not short circuit. These are useful for operations that require inspecting the entire list to calculate the final state.

Documentation

sum :: Num a => L' a a

Sum of the inputs

>>> run [1 .. 10] sum
55

product :: Num a => L' a a

Product of the input

>>> run [1 .. 10] product
3628800

count :: Enum e => L' a e

Count the number of elements fed to a fold

>>> run [1 .. 10] count
10

Note: GHCi will default Enum e to (). If you see

*** Exception: Prelude.Enum.().succ: bad argument

You've been bitten by this.

mconcat :: Monoid m => L' m m

mappend all the elements of a sequence together.

>>> run [[1, 2, 3, 4], [5, 6, 7, 8]] mconcat
[1, 2, 3, 4, 5, 6, 7, 8]

>>> run (map Sum [1, 2, 3, 4]) mconcat
Sum {getSum = 10}

minimum :: Ord a => L' a (Maybe a)

Minimum of all inputs. If no inputs are supplied this returns Nothing.

>>> run [1, 2, 3] minimum
1
>>> run [1 ..] minimum
... diverges ...

maximum :: Ord a => L' a (Maybe a)

Maximum of all inputs. If no inputs are supplied this returns Nothing.

>>> run [1, 2, 3] maximum
3

>>> run [1 ..] maximum
... diverges ...

nub :: Ord a => L' a [a]

De-duplicate all the inputs while preserving order. O(n log(n))

>>> run (replicate 10 1 ++ replicate 10 2) nub
[1, 2]

>>> run [1, 2, 1] nub
[1, 2]

slowNub :: Eq a => L' a [a]

De-duplicate all the inputs while preserving order. O(n^2). This should be equivalent (but slower) then nub for Ord types.

>>> run (replicate 10 1 ++ replicate 10 2) slowNub
[1, 2]

>>> run [1, 2, 1] slowNub
[1, 2]

intoSet :: Ord a => L' a (Set a)

Collect all members into a Set.

>>> run [1 .. 10] intoSet
fromList [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

last :: L' a (Maybe a)

Grab the last element inputted

>>> run [1 .. 10] last
Just 10

>>> run [] last
Nothing

nth :: (Eq b, Ord b, Num b) => b -> L' a (Maybe a)

Grab the nth element inputted.

>>> run [1 .. 10] (nth 5)
Just 6

>>> run [1 .. 10] (nth 20)
Nothing