# (a -> b -> c) -> b -> a -> c

flip f takes its (first) two arguments in the reverse order of f.
*Deprecated.* As of version 0.5, replaced by foldr.
*O(n)*. Fold the values in the map using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only.
*O(n)*. Fold the values in the map using the given right-associative binary operator, such that foldr f z == foldr f z . elems.
For example,
> elems map = foldr (:) [] map
> let f a len = len + (length a)
> foldr f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
*O(n)*. A strict version of foldr. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)*. Fold the elements in the set using the given right-associative binary operator. This function is an equivalent of foldr and is present for compatibility only.
*Please note that fold will be deprecated in the future and removed.*
*O(n)*. Fold the elements in the set using the given right-associative binary operator, such that foldr f z == foldr f z . toAscList.
For example,
> toAscList set = foldr (:) [] set
*O(n)*. A strict version of foldr. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
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)...)
Fold over the elements of a structure, associating to the right, but strictly.

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

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.
A strict version of foldl.
*O(n)*. Fold the elements in the set using the given left-associative binary operator, such that foldl f z == foldl f z . toAscList.
For example,
> toDescList set = foldl (flip (:)) [] set
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
*O(n)*. Fold the values in the map using the given left-associative binary operator, such that foldl f z == foldl f z . elems.
For example,
> elems = reverse . foldl (flip (:)) []
> let f len a = len + (length a)
> foldl f 0 (fromList [(5,"a"), (3,"bbb")]) == 4
*O(n)*. A strict version of foldl. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.
Consume the chunks of a lazy ByteString with a natural right fold.

Consume the chunks of a lazy Text with a natural right fold.
Consume the chunks of a lazy ByteString with a strict, tail-recursive, accumulating left fold.

Consume the chunks of a lazy Text with a strict, tail-recursive, accumulating left fold.
scanr is the right-to-left dual of scanl. Note that
> head (scanr f z xs) == foldr f z xs.
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.
scanl is similar to foldl, but returns a sequence of reduced values from the left:
> scanl f z (fromList [x1, x2, ...]) = fromList [z, z `f` x1, (z `f` x1) `f` x2, ...]
*O(n+m)*. The intersection with a combining function.
> intersectionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "aA"

*O(min(n1,n2))*. zipWith generalizes zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two sequences to take the sequence of corresponding sums.
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.
Lift a binary function to actions.

Promote a function to a monad, scanning the monadic arguments from left to right. For example,
> liftM2 (+) [0,1] [0,2] = [0,2,1,3]
> liftM2 (+) (Just 1) Nothing = Nothing

*O(n+m)*. Is this a proper submap? (ie. a submap but not equal). The expression (isProperSubmapOfBy f m1 m2) returns True when m1 and m2 are not equal, all keys in m1 are in m2, and when f returns True when applied to their respective values. For example, the following expressions are all True:
> isProperSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
> isProperSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
But the following are all False:
> isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)])
> isProperSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
> isProperSubmapOfBy (<) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
*O(n+m)*. The expression (isSubmapOfBy f m1 m2) returns True if all keys in m1 are in m2, and when f returns True when applied to their respective values. For example, the following expressions are all True:
> isSubmapOfBy (==) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
> isSubmapOfBy (<=) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
> isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1),(2,2)])
But the following are all False:
> isSubmapOfBy (==) (fromList [(1,2)]) (fromList [(1,1),(2,2)])
> isSubmapOfBy (<) (fromList [(1,1)]) (fromList [(1,1),(2,2)])
> isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
*O(n)* foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a Text, reduces the Text using the binary operator, from left to right. Subject to fusion.
*O(n)* A strict version of foldl. Subject to fusion.
foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right.
'foldl\'' is like foldl, but strict in the accumulator.

foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right.
Show more results