(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c -containers

scanl :: (a -> b -> a) -> a -> [b] -> [a]

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.

scanr :: (a -> b -> b) -> b -> [a] -> [b]

scanl is similar to foldl, but returns a list of successive reduced values from the left: > scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that > last (scanl f z xs) == foldl f z xs.

flip :: (a -> b -> c) -> b -> a -> c

scanr is the right-to-left dual of scanl. Note that > head (scanr f z xs) == foldr f z xs.

base Prelude, base Data.Function

flip f takes its (first) two arguments in the reverse order of f.

foldl :: Foldable t => (a -> b -> a) -> a -> t b -> a

foldl' :: Foldable t => (a -> b -> a) -> a -> t b -> a

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

Fold over the elements of a structure, associating to the left, but strictly.

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

The deleteFirstsBy function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

The intersectBy function is the non-overloaded version of intersect.

foldl :: (a -> b -> a) -> a -> [b] -> a

The unionBy function is the non-overloaded version of union.

foldl' :: (a -> b -> a) -> a -> [b] -> a

foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right: > foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn The list must be finite.

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

A strict version of foldl.

foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b

foldr :: (a -> b -> b) -> b -> [a] -> b

Fold over the elements of a structure, associating to the right, but strictly.

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left: > foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]

The deleteBy function behaves like delete, but takes a user-supplied equality predicate.