Hoogle Search
Within LTS Haskell 24.3 (ghc-9.10.2)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
foldl :: (a -> Char -> a) -> a -> JSString -> ajsaddle Data.JSString O(n) foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a JSString, reduces the JSString using the binary operator, from left to right. Subject to fusion.
foldl :: (b -> Char -> b) -> b -> Stream Char -> bjsaddle Data.JSString.Internal.Fusion.Common foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a Stream, reduces the Stream using the binary operator, from left to right. Properties
foldl f z0 . stream = foldl f z0
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> bnumeric-prelude NumericPrelude Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In the case of lists, foldl, when 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
Note that to produce the outermost application of the operator the entire input list must be traversed. Like all left-associative folds, foldl will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldl' instead of foldl. The reason for this is that the latter does not force the inner results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to:foldl f z = foldl f z . toList
Examples
The first example is a strict fold, which in practice is best performed with foldl'.>>> foldl (+) 42 [1,2,3,4] 52
Though the result below is lazy, the input is reversed before prepending it to the initial accumulator, so corecursion begins only after traversing the entire input string.>>> foldl (\acc c -> c : acc) "abcd" "efgh" "hgfeabcd"
A left fold of a structure that is infinite on the right cannot terminate, even when for any finite input the fold just returns the initial accumulator:>>> foldl (\a _ -> a) 0 $ repeat 1 * Hangs forever *
WARNING: When it comes to lists, you always want to use either foldl' or foldr instead.foldl :: Foldable t => (b -> a -> b) -> b -> t a -> bnumeric-prelude NumericPrelude.Base Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In the case of lists, foldl, when 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
Note that to produce the outermost application of the operator the entire input list must be traversed. Like all left-associative folds, foldl will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldl' instead of foldl. The reason for this is that the latter does not force the inner results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to:foldl f z = foldl f z . toList
Examples
The first example is a strict fold, which in practice is best performed with foldl'.>>> foldl (+) 42 [1,2,3,4] 52
Though the result below is lazy, the input is reversed before prepending it to the initial accumulator, so corecursion begins only after traversing the entire input string.>>> foldl (\acc c -> c : acc) "abcd" "efgh" "hgfeabcd"
A left fold of a structure that is infinite on the right cannot terminate, even when for any finite input the fold just returns the initial accumulator:>>> foldl (\a _ -> a) 0 $ repeat 1 * Hangs forever *
WARNING: When it comes to lists, you always want to use either foldl' or foldr instead.foldl :: Foldable t => (b -> a -> b) -> b -> t a -> bnumhask NumHask.Prelude Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In the case of lists, foldl, when 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
Note that to produce the outermost application of the operator the entire input list must be traversed. Like all left-associative folds, foldl will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldl' instead of foldl. The reason for this is that the latter does not force the inner results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to:foldl f z = foldl f z . toList
Examples
The first example is a strict fold, which in practice is best performed with foldl'.>>> foldl (+) 42 [1,2,3,4] 52
Though the result below is lazy, the input is reversed before prepending it to the initial accumulator, so corecursion begins only after traversing the entire input string.>>> foldl (\acc c -> c : acc) "abcd" "efgh" "hgfeabcd"
A left fold of a structure that is infinite on the right cannot terminate, even when for any finite input the fold just returns the initial accumulator:>>> foldl (\a _ -> a) 0 $ repeat 1 * Hangs forever *
WARNING: When it comes to lists, you always want to use either foldl' or foldr instead.foldl :: Foldable t => (b -> a -> b) -> b -> t a -> bnumhask NumHask.Prelude Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In the case of lists, foldl, when 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
Note that to produce the outermost application of the operator the entire input list must be traversed. Like all left-associative folds, foldl will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldl' instead of foldl. The reason for this is that the latter does not force the inner results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to:foldl f z = foldl f z . toList
Examples
The first example is a strict fold, which in practice is best performed with foldl'.>>> foldl (+) 42 [1,2,3,4] 52
Though the result below is lazy, the input is reversed before prepending it to the initial accumulator, so corecursion begins only after traversing the entire input string.>>> foldl (\acc c -> c : acc) "abcd" "efgh" "hgfeabcd"
A left fold of a structure that is infinite on the right cannot terminate, even when for any finite input the fold just returns the initial accumulator:>>> foldl (\a _ -> a) 0 $ repeat 1 * Hangs forever *
WARNING: When it comes to lists, you always want to use either foldl' or foldr instead.foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> aListLike Data.ListLike Left-associative fold
foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> aListLike Data.ListLike.FoldableLL Left-associative fold
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> bbasic-prelude BasicPrelude Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In the case of lists, foldl, when 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
Note that to produce the outermost application of the operator the entire input list must be traversed. Like all left-associative folds, foldl will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldl' instead of foldl. The reason for this is that the latter does not force the inner results (e.g. z `f` x1 in the above example) before applying them to the operator (e.g. to (`f` x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to:foldl f z = foldl f z . toList
Examples
The first example is a strict fold, which in practice is best performed with foldl'.>>> foldl (+) 42 [1,2,3,4] 52
Though the result below is lazy, the input is reversed before prepending it to the initial accumulator, so corecursion begins only after traversing the entire input string.>>> foldl (\acc c -> c : acc) "abcd" "efgh" "hgfeabcd"
A left fold of a structure that is infinite on the right cannot terminate, even when for any finite input the fold just returns the initial accumulator:>>> foldl (\a _ -> a) 0 $ repeat 1 * Hangs forever *
WARNING: When it comes to lists, you always want to use either foldl' or foldr instead.foldl :: (a -> b -> a) -> a -> Word64Map b -> aghc-lib-parser GHC.Data.Word64Map.Internal 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