Hoogle Search

Within LTS Haskell 24.21 (ghc-9.10.3)

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

Exact lookup

1. foldl' :: Vector v a => (b -> a -> b) -> b -> v a -> b

   fixed-vector	Data.Vector.Fixed

   Strict left fold over vector

2. foldl' :: forall (n :: PeanoNum) b a . ArityPeano n => (b -> a -> b) -> b -> ContVec n a -> b

   fixed-vector	Data.Vector.Fixed.Cont

   Strict left fold over continuation vector.

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

   mixed-types-num	Numeric.MixedTypes.PreludeHiding

   Left-associative fold of a structure but with strict application of the operator. This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result (e.g. sum). For a general Foldable structure this should be semantically identical to,

   foldl' f z = foldl' f z . toList
   

4. foldl' :: (r -> v -> r) -> r -> MonoidMap k v -> r

   monoidmap	Data.MonoidMap

   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.

5. foldl' :: (a -> b -> a) -> a -> NonEmptyVector b -> a

   nonempty-vector	Data.Vector.NonEmpty

   O(n) Strict Left monoidal fold

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

   LambdaHack	Game.LambdaHack.Core.Prelude

   Left-associative fold of a structure but with strict application of the operator. This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result (e.g. sum). For a general Foldable structure this should be semantically identical to,

   foldl' f z = foldl' f z . toList
   

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

   LambdaHack	Game.LambdaHack.Core.Prelude

   Left-associative fold of a structure but with strict application of the operator. This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result (e.g. sum). For a general Foldable structure this should be semantically identical to,

   foldl' f z = foldl' f z . toList
   

8. foldl' :: (Traversable t, Backprop a, Reifies s W) => (BVar s b -> BVar s a -> BVar s b) -> BVar s b -> BVar s (t a) -> BVar s b

   backprop	Prelude.Backprop

   Lifed foldl'. Essentially just toList composed with a normal list foldl', and is only here for convenience.

9. foldl' :: (Traversable t, Reifies s W) => AddFunc a -> ZeroFunc a -> (BVar s b -> BVar s a -> BVar s b) -> BVar s b -> BVar s (t a) -> BVar s b

   backprop	Prelude.Backprop.Explicit

   foldl', but taking explicit add and zero.

10. foldl' :: (Traversable t, Num a, Reifies s W) => (BVar s b -> BVar s a -> BVar s b) -> BVar s b -> BVar s (t a) -> BVar s b

    backprop	Prelude.Backprop.Num

    foldl', but with Num constraints instead of Backprop constraints.

Page 15 of many | Previous | Next