foldl -containers

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 :: Foldable t => (a -> b -> a) -> a -> t b -> a
base Data.Foldable
foldl :: (a -> Char -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
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 :: (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.
foldl :: (a -> Word8 -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Lazy
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 :: (a -> Word8 -> a) -> a -> ByteString -> a
bytestring Data.ByteString
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. This function is subject to array fusion.
package foldl
package
This library provides strict left folds that stream in constant memory, and you can combine folds using Applicative style to derive new folds.  Derived folds still traverse the container just once and are often as efficient as hand-written folds. Version 1.0.0
foldl1 :: (a -> a -> a) -> [a] -> a
base Prelude, base Data.List
foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty lists.
foldl' :: (a -> b -> a) -> a -> [b] -> a
base Data.List
A strict version of foldl.
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.
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
base Data.Foldable
foldl1' :: (a -> a -> a) -> [a] -> a
base Data.List
A strict version of foldl1
foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a
base Data.Foldable
Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.
foldl' :: (a -> Char -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
'foldl\'' is like foldl, but strict in the accumulator.
foldl' :: (a -> Char -> a) -> a -> Text -> a
text Data.Text, text Data.Text.Lazy
O(n) A strict version of foldl. Subject to fusion.
foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
bytestring Data.ByteString.Lazy
'foldl\'' is like foldl, but strict in the accumulator.
foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
bytestring Data.ByteString
'foldl\'' is like foldl, but strict in the accumulator. However, for ByteStrings, all left folds are strict in the accumulator.
foldl1 :: (Char -> Char -> Char) -> ByteString -> Char
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty ByteStrings.
foldl1 :: (Char -> Char -> Char) -> Text -> Char
text Data.Text, text Data.Text.Lazy
O(n) A variant of foldl that has no starting value argument, and thus must be applied to a non-empty Text. Subject to fusion.
foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8
bytestring Data.ByteString.Lazy
foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty ByteStrings. This function is subject to array fusion.

Show more results