(a -> b -> c) -> b -> a -> c -containers

flip :: (a -> b -> c) -> b -> a -> c
base Prelude, base Data.Function
flip f takes its (first) two arguments in the reverse order of f.
foldr :: (a -> b -> b) -> b -> [a] -> b
base Prelude, base Data.List
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)...)
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
base Data.Foldable
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
base Data.Foldable
Fold over the elements of a structure, associating to the right, but strictly.
foldl :: Foldable t => (a -> b -> a) -> a -> t b -> a
base Data.Foldable
foldl' :: Foldable t => (a -> b -> a) -> a -> t b -> a
base Data.Foldable
Fold over the elements of a structure, associating to the left, but strictly.
foldl :: (a -> b -> a) -> a -> [b] -> a
base Prelude, base Data.List
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.
foldl' :: (a -> b -> a) -> a -> [b] -> a
base Data.List
A strict version of foldl.
foldrChunks :: (ByteString -> a -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Lazy
Consume the chunks of a lazy ByteString with a natural right fold.
foldrChunks :: (Text -> a -> a) -> a -> Text -> a
text Data.Text.Lazy.Internal, text Data.Text.Lazy
Consume the chunks of a lazy Text with a natural right fold.
foldlChunks :: (a -> ByteString -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Lazy
Consume the chunks of a lazy ByteString with a strict, tail-recursive, accumulating left fold.
foldlChunks :: (a -> Text -> a) -> a -> Text -> a
text Data.Text.Lazy.Internal, text Data.Text.Lazy
Consume the chunks of a lazy Text with a strict, tail-recursive, accumulating left fold.
scanr :: (a -> b -> b) -> b -> [a] -> [b]
base Prelude, base Data.List
scanr is the right-to-left dual of scanl. Note that > head (scanr f z xs) == foldr f z xs.
scanl :: (a -> b -> a) -> a -> [b] -> [a]
base Prelude, base Data.List
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.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
base Prelude, base Data.List
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.
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
base Control.Applicative
Lift a binary function to actions.
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
base Control.Monad
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
gmapQr :: Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
base Data.Data
gmapQl :: Data a => (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
base Data.Data
foldl :: (a -> Char -> a) -> a -> Text -> a
text Data.Text, text Data.Text.Lazy
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.

Show more results