Hoogle Search

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

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

xmonad-contrib XMonad.Config.Prime

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 -> b

xmonad-contrib XMonad.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.
module Data.Conduit.Foldl

Adapter module to work with the foldl package.
module Control.Foldl

This module provides efficient and streaming left folds that you can combine using Applicative style. Import this module qualified to avoid clashing with the Prelude:
```
>>> import qualified Control.Foldl as Foldl
```
Use fold to apply a Fold to a list:
```
>>> Foldl.fold Foldl.sum [1..100]
5050
```
Folds are Applicatives, so you can combine them using Applicative combinators:
```
>>> import Control.Applicative

>>> let average = (/) <$> Foldl.sum <*> Foldl.genericLength
```
… or you can use do notation if you enable the ApplicativeDo language extension:
```
>>> :set -XApplicativeDo

>>> let average = do total <- Foldl.sum; count <- Foldl.genericLength; return (total / count)
```
… or you can use the fact that the Fold type implements Num to do this:
```
>>> let average = Foldl.sum / Foldl.genericLength
```
These combined folds will still traverse the list only once, streaming efficiently over the list in constant space without space leaks:
```
>>> Foldl.fold average [1..10000000]
5000000.5

>>> Foldl.fold ((,) <$> Foldl.minimum <*> Foldl.maximum) [1..10000000]
(Just 1,Just 10000000)
```
You might want to try enabling the -flate-dmd-anal flag when compiling executables that use this library to further improve performance.
type family Foldl (arg :: b ~> a ~> b) (arg1 :: b) (arg2 :: t a) :: b

singletons-base Data.List.Singletons

No documentation available.
type family Foldl (f :: b ~> a ~> b) (z :: b) (xs :: [a]) :: b

defun-core DeFun.List

List left fold
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

base 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
```

xmonad-contrib	XMonad.Config.Prime

xmonad-contrib	XMonad.Prelude

singletons-base	Data.List.Singletons

defun-core	DeFun.List

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

base	Prelude

A variant of foldl that has no base case, and thus may only be applied to non-empty structures. This function is non-total and will raise a runtime exception if the structure happens to be empty.

foldl1 f = foldl1 f . toList

Examples

Basic usage:

>>> foldl1 (+) [1..4]
10

>>> foldl1 (+) []
*** Exception: Prelude.foldl1: empty list

>>> foldl1 (+) Nothing
*** Exception: foldl1: empty structure

>>> foldl1 (-) [1..4]
-8

>>> foldl1 (&&) [True, False, True, True]
False

>>> foldl1 (||) [False, False, True, True]
True

>>> foldl1 (+) [1..]
* Hangs forever *

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

base Data.List

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
```

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

base	Data.List

A variant of foldl that has no base case, and thus may only be applied to non-empty structures. This function is non-total and will raise a runtime exception if the structure happens to be empty.

foldl1 f = foldl1 f . toList

Examples

Basic usage:

>>> foldl1 (+) [1..4]
10

>>> foldl1 (+) []
*** Exception: Prelude.foldl1: empty list

>>> foldl1 (+) Nothing
*** Exception: foldl1: empty structure

>>> foldl1 (-) [1..4]
-8

>>> foldl1 (&&) [True, False, True, True]
False

>>> foldl1 (||) [False, False, True, True]
True

>>> foldl1 (+) [1..]
* Hangs forever *

Page 21 of many | Previous | Next