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' :: (b -> k -> b) -> b -> IntervalSet k -> b

   IntervalMap	Data.IntervalSet

   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.

2. foldl' :: MonoFoldable mono => (a -> Element mono -> a) -> a -> mono -> a

   classy-prelude-yesod	ClassyPrelude.Yesod

   Synonym for ofoldl'

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

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

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

   constrained-categories	Control.Category.Hask

   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
   

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

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

6. 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 with strict accumulator

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

   listsafe	Data.List.Safe

   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' :: KnownHashSet s a => (b -> Element s a -> b) -> b -> b

   refined-containers	Data.HashSet.Refined

   Left associative fold with a strict accumulator.

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

   refined-containers	Data.IntSet.Refined

   Left associative fold with a strict accumulator.

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

    refined-containers	Data.Set.Refined

    Left associative fold with a strict accumulator.

Page 20 of many | Previous | Next