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.
foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8
bytestring Data.ByteString
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. An exception will be thrown in the case of an empty ByteString.
foldl1' :: (Char -> Char -> Char) -> ByteString -> Char
bytestring Data.ByteString.Lazy.Char8
'foldl1\'' is like foldl1, but strict in the accumulator.
foldl1' :: (Char -> Char -> Char) -> ByteString -> Char
bytestring Data.ByteString.Char8
A strict version of foldl1
foldl1' :: (Char -> Char -> Char) -> Text -> Char
text Data.Text, text Data.Text.Lazy
O(n) A strict version of foldl1. Subject to fusion.
foldl1' :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8
bytestring Data.ByteString.Lazy
'foldl1\'' is like foldl1, but strict in the accumulator.
foldl1' :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8
bytestring Data.ByteString
'foldl1\'' is like foldl1, but strict in the accumulator. An exception will be thrown in the case of an empty ByteString.
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.
gfoldl :: Data a => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
base Data.Data
gfoldlAccum :: Data d => (forall e r. Data e => a -> c (e -> r) -> e -> (a, c r)) -> (forall g. a -> g -> (a, c g)) -> a -> d -> (a, c d)
syb Data.Generics.Twins
gfoldl with accumulation