Fold

Fold types

data Fold a b

Processes inputs of type a and results in a value of type b

Constructors

forall x. Fold x (x -> a -> x) (x -> b)

Instances

Applicative (Fold a)

Defined in Fold.Pure.Type

Methods

pure :: a0 -> Fold a a0

(<*>) :: Fold a (a0 -> b) -> Fold a a0 -> Fold a b

liftA2 :: (a0 -> b -> c) -> Fold a a0 -> Fold a b -> Fold a c

(*>) :: Fold a a0 -> Fold a b -> Fold a b

(<*) :: Fold a a0 -> Fold a b -> Fold a a0

Functor (Fold a)

Defined in Fold.Pure.Type

Methods

fmap :: (a0 -> b) -> Fold a a0 -> Fold a b

(<$) :: a0 -> Fold a b -> Fold a a0

Monoid b => Monoid (Fold a b)

Defined in Fold.Pure.Type

Methods

mempty :: Fold a b

mappend :: Fold a b -> Fold a b -> Fold a b

mconcat :: [Fold a b] -> Fold a b

Semigroup b => Semigroup (Fold a b)

Defined in Fold.Pure.Type

Methods

(<>) :: Fold a b -> Fold a b -> Fold a b

sconcat :: NonEmpty (Fold a b) -> Fold a b

stimes :: Integral b0 => b0 -> Fold a b -> Fold a b

data NonemptyFold a b

Processes at least one input of type a and results in a value of type b

Constructors

forall x. NonemptyFold (a -> x) (x -> a -> x) (x -> b)

Instances

Applicative (NonemptyFold a)

Defined in Fold.Nonempty.Type

Methods

pure :: a0 -> NonemptyFold a a0

(<*>) :: NonemptyFold a (a0 -> b) -> NonemptyFold a a0 -> NonemptyFold a b

liftA2 :: (a0 -> b -> c) -> NonemptyFold a a0 -> NonemptyFold a b -> NonemptyFold a c

(*>) :: NonemptyFold a a0 -> NonemptyFold a b -> NonemptyFold a b

(<*) :: NonemptyFold a a0 -> NonemptyFold a b -> NonemptyFold a a0

Functor (NonemptyFold a)

Defined in Fold.Nonempty.Type

Methods

fmap :: (a0 -> b) -> NonemptyFold a a0 -> NonemptyFold a b

(<$) :: a0 -> NonemptyFold a b -> NonemptyFold a a0

Monoid b => Monoid (NonemptyFold a b)

Defined in Fold.Nonempty.Type

Methods

mempty :: NonemptyFold a b

mappend :: NonemptyFold a b -> NonemptyFold a b -> NonemptyFold a b

mconcat :: [NonemptyFold a b] -> NonemptyFold a b

Semigroup b => Semigroup (NonemptyFold a b)

Defined in Fold.Nonempty.Type

Methods

(<>) :: NonemptyFold a b -> NonemptyFold a b -> NonemptyFold a b

sconcat :: NonEmpty (NonemptyFold a b) -> NonemptyFold a b

stimes :: Integral b0 => b0 -> NonemptyFold a b -> NonemptyFold a b

data EffectfulFold m a b

Processes inputs of type a and results in an effectful value of type m b

Constructors

forall x. EffectfulFold (m x) (x -> a -> m x) (x -> m b)

Instances

Applicative m => Applicative (EffectfulFold m a)

Defined in Fold.Effectful.Type

Methods

pure :: a0 -> EffectfulFold m a a0

(<*>) :: EffectfulFold m a (a0 -> b) -> EffectfulFold m a a0 -> EffectfulFold m a b

liftA2 :: (a0 -> b -> c) -> EffectfulFold m a a0 -> EffectfulFold m a b -> EffectfulFold m a c

(*>) :: EffectfulFold m a a0 -> EffectfulFold m a b -> EffectfulFold m a b

(<*) :: EffectfulFold m a a0 -> EffectfulFold m a b -> EffectfulFold m a a0

Functor m => Functor (EffectfulFold m a)

Defined in Fold.Effectful.Type

Methods

fmap :: (a0 -> b) -> EffectfulFold m a a0 -> EffectfulFold m a b

(<$) :: a0 -> EffectfulFold m a b -> EffectfulFold m a a0

(Monoid b, Monad m) => Monoid (EffectfulFold m a b)

Defined in Fold.Effectful.Type

Methods

mempty :: EffectfulFold m a b

mappend :: EffectfulFold m a b -> EffectfulFold m a b -> EffectfulFold m a b

mconcat :: [EffectfulFold m a b] -> EffectfulFold m a b

(Semigroup b, Monad m) => Semigroup (EffectfulFold m a b)

Defined in Fold.Effectful.Type

Methods

(<>) :: EffectfulFold m a b -> EffectfulFold m a b -> EffectfulFold m a b

sconcat :: NonEmpty (EffectfulFold m a b) -> EffectfulFold m a b

stimes :: Integral b0 => b0 -> EffectfulFold m a b -> EffectfulFold m a b

data ShortcutFold a b

Processes inputs of type a, has the ability to halt midway through the stream, and results in a value of type b

Constructors

forall x y. ShortcutFold (Vitality x y) (y -> a -> Vitality x y) (x -> b) (y -> b)

Instances

Applicative (ShortcutFold a)

Defined in Fold.Shortcut.Type

Methods

pure :: a0 -> ShortcutFold a a0

(<*>) :: ShortcutFold a (a0 -> b) -> ShortcutFold a a0 -> ShortcutFold a b

liftA2 :: (a0 -> b -> c) -> ShortcutFold a a0 -> ShortcutFold a b -> ShortcutFold a c

(*>) :: ShortcutFold a a0 -> ShortcutFold a b -> ShortcutFold a b

(<*) :: ShortcutFold a a0 -> ShortcutFold a b -> ShortcutFold a a0

Functor (ShortcutFold a)

Defined in Fold.Shortcut.Type

Methods

fmap :: (a0 -> b) -> ShortcutFold a a0 -> ShortcutFold a b

(<$) :: a0 -> ShortcutFold a b -> ShortcutFold a a0

Monoid b => Monoid (ShortcutFold a b)

Defined in Fold.Shortcut.Type

Methods

mempty :: ShortcutFold a b

mappend :: ShortcutFold a b -> ShortcutFold a b -> ShortcutFold a b

mconcat :: [ShortcutFold a b] -> ShortcutFold a b

Semigroup b => Semigroup (ShortcutFold a b)

Defined in Fold.Shortcut.Type

Methods

(<>) :: ShortcutFold a b -> ShortcutFold a b -> ShortcutFold a b

sconcat :: NonEmpty (ShortcutFold a b) -> ShortcutFold a b

stimes :: Integral b0 => b0 -> ShortcutFold a b -> ShortcutFold a b

data ShortcutNonemptyFold a b

Processes at least one input of type a, has the ability to halt midway through the stream, and results in a value of type b

Constructors

forall x y. ShortcutNonemptyFold (a -> Vitality x y) (y -> a -> Vitality x y) (x -> b) (y -> b)

Instances

Applicative (ShortcutNonemptyFold a)

Defined in Fold.ShortcutNonempty.Type

Methods

pure :: a0 -> ShortcutNonemptyFold a a0

(<*>) :: ShortcutNonemptyFold a (a0 -> b) -> ShortcutNonemptyFold a a0 -> ShortcutNonemptyFold a b

liftA2 :: (a0 -> b -> c) -> ShortcutNonemptyFold a a0 -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a c

(*>) :: ShortcutNonemptyFold a a0 -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b

(<*) :: ShortcutNonemptyFold a a0 -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a a0

Functor (ShortcutNonemptyFold a)

Defined in Fold.ShortcutNonempty.Type

Methods

fmap :: (a0 -> b) -> ShortcutNonemptyFold a a0 -> ShortcutNonemptyFold a b

(<$) :: a0 -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a a0

Monoid b => Monoid (ShortcutNonemptyFold a b)

Defined in Fold.ShortcutNonempty.Type

Methods

mempty :: ShortcutNonemptyFold a b

mappend :: ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b

mconcat :: [ShortcutNonemptyFold a b] -> ShortcutNonemptyFold a b

Semigroup b => Semigroup (ShortcutNonemptyFold a b)

Defined in Fold.ShortcutNonempty.Type

Methods

(<>) :: ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b

sconcat :: NonEmpty (ShortcutNonemptyFold a b) -> ShortcutNonemptyFold a b

stimes :: Integral b0 => b0 -> ShortcutNonemptyFold a b -> ShortcutNonemptyFold a b

data Vitality a b

Constructors

Dead a

Alive Will b

Instances

Functor (Vitality a)

Defined in Strict

Methods

fmap :: (a0 -> b) -> Vitality a a0 -> Vitality a b

(<$) :: a0 -> Vitality a b -> Vitality a a0

data Will

Constructors

Ambivalent

Tenacious

Instances

Monoid Will

Defined in Strict

Methods

mempty :: Will

mappend :: Will -> Will -> Will

mconcat :: [Will] -> Will

Semigroup Will

Defined in Strict

Methods

(<>) :: Will -> Will -> Will

sconcat :: NonEmpty Will -> Will

stimes :: Integral b => b -> Will -> Will

Running

runFold :: Foldable f => Fold a b -> f a -> b

Fold a listlike container to a single summary result

runNonemptyFold :: NonemptyFold a b -> NonEmpty a -> b

Fold a nonempty listlike container to a single summary result

runEffectfulFold :: Foldable f => Monad m => EffectfulFold m a b -> f a -> m b

Fold an listlike container to an action that produces a single summary result

Search

element :: Eq a => a -> ShortcutFold a Bool

True if any input is equal to the given value (tenacious)

notElement :: Eq a => a -> ShortcutFold a Bool

False if any input is equal to the given value (tenacious)

find :: (a -> Bool) -> ShortcutFold a (Maybe a)

The first input that satisfies the predicate, if any (tenacious)

lookup :: Eq a => a -> ShortcutFold (a, b) (Maybe b)

The b from the first tuple where a equals the given value, if any (tenacious)

Arithmetic folds

sum :: Num a => Fold a a

Adds the inputs

product :: Num a => Fold a a

Multiplies the inputs

mean :: Fractional a => Fold a a

Numerically stable arithmetic mean of the inputs

variance :: Fractional a => Fold a a

Numerically stable (population) variance over the inputs

standardDeviation :: Floating a => Fold a a

Numerically stable (population) standard deviation over the inputs

Working with indices

index :: Natural -> ShortcutFold a (Maybe a)

The nth input, where n=0 is the first input, if the index is in bounds (tenacious)

findIndex :: (a -> Bool) -> ShortcutFold a (Maybe Natural)

The index of the first input that satisfies the predicate, if any (tenacious)

elementIndex :: Eq a => a -> ShortcutFold a (Maybe Natural)

The index of the first input that matches the given value, if any (tenacious)

Counting inputs

null :: ShortcutFold a Bool

True if the input contains no inputs (tenacious)

length :: Fold a Natural

The number of inputs

Boolean folds

and :: ShortcutFold Bool Bool

True if all inputs are True (tenacious)

or :: ShortcutFold Bool Bool

True if any input is True (tenacious)

all :: (a -> Bool) -> ShortcutFold a Bool

True if all inputs satisfy the predicate (tenacious)

any :: (a -> Bool) -> ShortcutFold a Bool

True if any input satisfies the predicate (tenacious)

Min/max

maximum :: Ord a => NonemptyFold a a

The greatest input

minimum :: Ord a => NonemptyFold a a

The least input

maximumBy :: (a -> a -> Ordering) -> NonemptyFold a a

The greatest input with respect to the given comparison function

minimumBy :: (a -> a -> Ordering) -> NonemptyFold a a

The least input with respect to the given comparison function

First/last

first :: ShortcutNonemptyFold a a

The first input (tenacious)

last :: NonemptyFold a a

The last input

General folds

magma :: (a -> a -> a) -> NonemptyFold a a

Start with the first input, append each new input on the right with the given function

semigroup :: Semigroup a => NonemptyFold a a

Append each new input on the right with (<>)

monoid :: Monoid a => Fold a a

Start with mempty, append each input on the right with (<>)

effect :: Monad m => (a -> m b) -> EffectfulFold m a ()

Performs an action for each input, discarding the result

effectMonoid :: (Monoid w, Monad m) => (a -> m w) -> EffectfulFold m a w

Performs an action for each input, monoidally combining the results from all the actions.

List folds

list :: Fold a [a]

All the inputs

reverseList :: Fold a [a]

All the inputs in reverse order

nonemptyList :: NonemptyFold a (NonEmpty a)

All the inputs from a nonempty fold

reverseNonemptyList :: NonemptyFold a (NonEmpty a)

All the inputs from a nonempty fold, in reverse order

Fold conversions

emptyToNonempty :: Fold a b -> NonemptyFold a b

Turn a regular fold that allows empty input into a fold that requires at least one input

nonemptyToEmpty :: NonemptyFold a b -> Fold a (Maybe b)

Turn a fold that requires at least one input into a fold that returns Nothing when there are no inputs

pureToEffectful :: Monad m => Fold a b -> EffectfulFold m a b

Generalize a pure fold to an effectful fold

effectfulToPure :: EffectfulFold Identity a b -> Fold a b

Turn an effectful fold into a pure fold

nonemptyToEffectful :: Monad m => NonemptyFold a b -> EffectfulFold m a (Maybe b)

Turn a nonempty fold that requires at least one input into a fold that returns Nothing when there are no inputs

effectfulToNonempty :: EffectfulFold Identity a b -> NonemptyFold a b

Turn an effectful fold into a pure fold that requires at least one input

Hoist

hoist :: (forall x. m x -> n x) -> EffectfulFold m a b -> EffectfulFold n a b

Shift an effectful fold from one monad to another with a morphism such as lift or liftIO

Duplicate

duplicateFold :: Fold a b -> Fold a (Fold a b)

Allows to continue feeding a fold even after passing it to a function that closes it

duplicateNonemptyFold :: NonemptyFold a b -> NonemptyFold a (Fold a b)

Allows to continue feeding a fold even after passing it to a function that closes it

duplicateEffectfulFold :: Applicative m => EffectfulFold m a b -> EffectfulFold m a (EffectfulFold m a b)

Allows to continue feeding an effectful fold even after passing it to a function that closes it