Fold.md

Module Control.Fold

This module provides a type Fold for lefts folds, which can be combined using the Applicative class:

average :: Fold Number Number
average = (/) <$> sum <*> length

Fold can be used to fold a Foldable structure (foldl), or scan a Traversable structure (scanl):

finalAverage = foldl average [1.0, 2.0, 3.0] :: Number
movingAverage = scanl average [1.0, 2.0, 3.0] :: Array Number

This library is based on the foldl library by Gabriel Gonzalez: http://hackage.haskell.org/package/foldl

Fold

newtype Fold a b

A left fold, which takes zero or more values of type a as input and produces output of type b.

Instances

Profunctor Fold
Closed Fold
Functor (Fold a)
Apply (Fold a)
Applicative (Fold a)
Extend (Fold a)
Comonad (Fold a)
(Semigroup b) => Semigroup (Fold a b)
(Monoid b) => Monoid (Fold a b)

stepFold

stepFold :: forall a b. a -> Fold a b -> Fold a b

Step a fold by providing a single input.

unfoldFold

unfoldFold :: forall s a b. s -> (s -> a -> s) -> (s -> b) -> Fold a b

Create a Fold by providing an initial state, a function which updates that state, and a function which produces output from a state.

unfoldFold_

unfoldFold_ :: forall a b. b -> (b -> a -> b) -> Fold a b

Create a Fold by providing an initial state and a function which updates that state. This is a variant of unfoldFold where the output is the state itself.

foldl

foldl :: forall f a b. Foldable f => Fold a b -> f a -> b

Run a Fold by providing a Foldable container of inputs, and then generating a single output. This is analogous to the foldl function from Data.Foldable.

scanl

scanl :: forall f a b. Traversable f => Fold a b -> f a -> f b

Run a Fold by providing a Traversable container of inputs, and generating an output for each input. This is analogous to the scanl function from Data.Traversable.

mconcat

mconcat :: forall m. Monoid m => Fold m m

Fold values in some Monoid.

head

head :: forall a. Fold a (Maybe a)

A Fold which remembers the first input.

last

last :: forall a. Fold a (Maybe a)

A Fold which keeps the last input.

null

null :: forall a. Fold a Boolean

A Fold which tests whether any inputs were seen.

length

length :: forall a s. Semiring s => Fold a s

A Fold which counts its inputs.

and

and :: forall b. HeytingAlgebra b => Fold b b

A Fold which tests if all of its inputs were true (generalized to work with an arbitrary HeytingAlgebra).

or

or :: forall b. HeytingAlgebra b => Fold b b

A Fold which tests if any of its inputs were true (generalized to work with an arbitrary HeytingAlgebra).

any

any :: forall a b. HeytingAlgebra b => (a -> b) -> Fold a b

A Fold which tests if any of its inputs satisfy some predicate (generalized to work with an arbitrary HeytingAlgebra).

all

all :: forall a b. HeytingAlgebra b => (a -> b) -> Fold a b

A Fold which tests if all of its inputs satisfy some predicate (generalized to work with an arbitrary HeytingAlgebra).

sum

sum :: forall s. Semiring s => Fold s s

A Fold which computes the sum of its inputs (generalized to work with an arbitrary Semiring).

product

product :: forall s. Semiring s => Fold s s

A Fold which computes the product of its inputs (generalized to work with an arbitrary Semiring).

maximum

maximum :: forall a. Bounded a => Fold a a

A Fold which computes the maximum of its inputs (generalized to work with an arbitrary Bounded type).

minimum

minimum :: forall a. Bounded a => Fold a a

A Fold which computes the minimum of its inputs (generalized to work with an arbitrary Bounded type).

elem

elem :: forall a. Eq a => a -> Fold a Boolean

A Fold which tests if a specific value appeared as an input.

notElem

notElem :: forall a. Eq a => a -> Fold a Boolean

A Fold which tests if a specific value did not appear as an input.

distributed

distributed :: forall f a b. Distributive f => Fold a b -> Fold (f a) (f b)

Fold over entire collections of inputs, producing a collection of outputs.