Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. foldl :: (a -> Bool -> a) -> a -> BV -> a

    bv Data.BitVector 

    foldl f z (fromBits [un, ..., u1, u0]) == ((((z `f` un) `f` ...) `f` u1) `f` u0)

    foldl f e = fromBits . foldl f e . toBits

  2. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

    constrained-categories Control.Category.Constrained.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.

  3. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

    constrained-categories Control.Category.Hask

    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.

  4. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

    copilot-language Copilot.Language.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.

  5. foldl :: forall (u :: Type -> Type) a (v :: Type -> Type) b r . (Vector u a, Vector v b) => (r -> (a, b) -> r) -> r -> Vector u v (a, b) -> r

    hybrid-vectors Data.Vector.Hybrid

    O(n) Left fold

  6. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

    listsafe Data.List.Safe

    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.

  7. foldl :: KnownHashSet s a => (b -> Element s a -> b) -> b -> b

    refined-containers Data.HashSet.Refined

    Left associative fold with a lazy accumulator.

  8. foldl :: KnownIntSet s => (a -> Element s -> a) -> a -> a

    refined-containers Data.IntSet.Refined

    Left associative fold with a lazy accumulator.

  9. foldl :: KnownSet s a => (b -> Element s a -> b) -> b -> b

    refined-containers Data.Set.Refined

    Left associative fold with a lazy accumulator.

  10. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

    verset Verset

    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.

Page 20 of many | Previous | Next