foldl -text -bytestring -package

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 -> Key -> a) -> a -> IntSet -> a
containers Data.IntSet
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
foldl :: (a -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
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
foldl :: (a -> b -> a) -> a -> Map k b -> a
containers Data.Map.Lazy, containers Data.Map.Strict
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
foldl :: (a -> b -> a) -> a -> Set b -> a
containers Data.Set
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
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 -> Key -> a) -> a -> IntSet -> a
containers Data.IntSet
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.
foldl' :: (a -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
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.
foldl' :: (a -> b -> a) -> a -> Map k b -> a
containers Data.Map.Lazy, containers Data.Map.Strict
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.
foldl' :: (a -> b -> a) -> a -> Set b -> a
containers Data.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.
foldlWithIndex :: (b -> Int -> a -> b) -> b -> Seq a -> b
containers Data.Sequence
foldlWithIndex is a version of foldl that also provides access to the index of each element.
foldlWithKey :: (a -> Key -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). Fold the keys and values in the map using the given left-associative binary operator, such that foldlWithKey f z == foldl (\z' (kx, x) -> f z' kx x) z . toAscList. For example, > keys = reverse . foldlWithKey (\ks k x -> k:ks) [] > let f result k a = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")" > foldlWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (3:b)(5:a)"
foldlWithKey :: (a -> k -> b -> a) -> a -> Map k b -> a
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Fold the keys and values in the map using the given left-associative binary operator, such that foldlWithKey f z == foldl (\z' (kx, x) -> f z' kx x) z . toAscList. For example, > keys = reverse . foldlWithKey (\ks k x -> k:ks) [] > let f result k a = result ++ "(" ++ (show k) ++ ":" ++ a ++ ")" > foldlWithKey f "Map: " (fromList [(5,"a"), (3,"b")]) == "Map: (3:b)(5:a)"
foldlWithKey' :: (a -> Key -> b -> a) -> a -> IntMap b -> a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n). A strict version of foldlWithKey. Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.

Show more results