Control.Foldl.Transduce

This module builds on module Control.Foldl, adding stateful transducers and grouping operations.

Transducer types

type Transduction a b = forall x. Fold b x -> Fold a x

A (possibly stateful) transformation on the inputs of a Fold.

Functions constructed with combinators like premap or handles from Control.Foldl also typecheck as a Transduction.

type Transduction' a b r = forall x. Fold b x -> Fold a (r, x)

A more general from of Transduction that adds new information to the return value of the Fold.

data Transducer i o r

A stateful process that transforms a stream of inputs into a stream of outputs, and may optionally demarcate groups in the stream of outputs.

Composed of a step function, an initial state, and a extraction function.

The step function returns a triplet of:

• The new internal state.
• Outputs that continues the last segment detected in the previous step.

• A list of lists containing outputs for segments detected in the current step. If the list is empty, that means no splitting has taken place in the current step. Transducers that do not perform grouping never return anything other than [] here. In effect, they treat the whole stream as a single group.

  The extraction function returns the Transducers own result value, as well as any pending outputs.

Constructors

forall x . Transducer (x -> i -> (x, [o], [[o]])) x (x -> (r, [o]))

Instances

Bifunctor (Transducer i)

Functor (Transducer i o)

type TransductionM m a b = forall x. Monad m => FoldM m b x -> FoldM m a x

Like Transduction, but works on monadic Folds.

type TransductionM' m a b r = forall x. FoldM m b x -> FoldM m a (r, x)

Like Transduction', but works on monadic Folds.

data TransducerM m i o r

Like Transducer, but monadic.

Constructors

forall x . TransducerM (x -> i -> m (x, [o], [[o]])) (m x) (x -> m (r, [o]))

Instances

(Functor m, Monad m) => Bifunctor (TransducerM m i)

Monad m => Functor (TransducerM m i o)

Applying transducers

transduce :: Transducer i o r -> Transduction i o

Apply a Transducer to a Fold, discarding the return value of the Transducer.

>>> L.fold (transduce (Transducer (\_ i -> ((),[i],[])) () (\_ -> ('r',[]))) L.list) [1..7]
[1,2,3,4,5,6,7]

transduce' :: Transducer i o x -> Transduction' i o x

Generalized version of transduce that preserves the return value of the Transducer.

>>> L.fold (transduce' (Transducer (\_ i -> ((),[i],[])) () (\_ -> ('r',[]))) L.list) [1..7]
('r',[1,2,3,4,5,6,7])

transduceM :: Monad m => TransducerM m i o r -> TransductionM m i o

Like transduce, but works on monadic Folds.

transduceM' :: Monad m => TransducerM m i o x -> TransductionM' m i o x

Like transduce', but works on monadic Folds.

Working with groups

groups :: Transducer i i' r -> Transduction i' b -> Transduction i b

Repeatedly applies a Transduction to process each of the groups demarcated by a Transducer, returning a Fold what works over the undivided stream of inputs. The return value of the Transducer is discarded.

>>> L.fold (groups (chunksOf 2) (transduce (surround "<" ">")) L.list) "aabbccdd"
"<aa><bb><cc><dd>"

groups'

Arguments

:: Transducer i i' s

-> Fold u v

auxiliary Fold that aggregates the u values produced for each group

-> Transduction' i' a u

repeatedly applied for processing each group

-> Transduction' i a (s, v)

Generalized version of groups that preserves the return value of the Transducer.

A summary value for each group is also calculated. They are aggregated for the whole stream, with the help of an auxiliary Fold.

>>> L.fold (groups' (chunksOf 2) L.list (\f -> transduce (surround "<" ">") (liftA2 (,) L.list f)) L.list) "aabbccdd"
(((),["<aa>","<bb>","<cc>","<dd>"]),"<aa><bb><cc><dd>")

groupsM :: Monad m => TransducerM m i i' s -> TransductionM m i' b -> TransductionM m i b

Monadic version of groups.

groupsM' :: Monad m => TransducerM m i i' s -> FoldM m u v -> TransductionM' m i' a u -> TransductionM' m i a (s, v)

Monadic version of groups'.

folds :: Transducer i i' r -> Fold i' b -> Transduction i b

Summarizes each of the groups demarcated by the Transducer using a Fold.

The result value of the Transducer is discarded.

folds' :: Transducer i i' s -> Fold i' b -> Transduction' i b s

Like folds, but preserves the return value of the Transducer.

foldsM :: (Applicative m, Monad m) => TransducerM m i i' r -> FoldM m i' b -> TransductionM m i b

Monadic version of folds.

foldsM' :: (Applicative m, Monad m) => TransducerM m i i' s -> FoldM m i' b -> TransductionM' m i b s

Monadic version of folds'.

Transducers

surround :: (Foldable p, Foldable s) => p a -> s a -> Transducer a a ()

Adds a prefix and a suffix to the stream arriving into a Fold.

>>> L.fold (transduce (surround "prefix" "suffix") L.list) "middle"
"prefixmiddlesuffix"

surroundIO :: (Foldable p, Foldable s, Functor m, MonadIO m) => m (p a) -> m (s a) -> TransducerM m a a ()

Like surround, but the prefix and suffix are obtained using a IO action.

>>> L.foldM (transduceM (surroundIO (return "prefix") (return "suffix")) (L.generalize L.list)) "middle"
"prefixmiddlesuffix"

Splitters

chunksOf :: Int -> Transducer a a ()

Splits a stream into chunks of fixed size.

>>> L.fold (folds (chunksOf 2) L.list L.list) [1..7]
[[1,2],[3,4],[5,6],[7]]

>>> L.fold (groups (chunksOf 2) (transduce (surround [] [0])) L.list) [1..7]
[1,2,0,3,4,0,5,6,0,7,0]

Transducer utilities

_generalize :: Monad m => Transducer i o r -> TransducerM m i o r

Generalize a Transducer to a TransducerM.

_simplify :: TransducerM Identity i o r -> Transducer i o r

Simplify a pure TransducerM to a Transducer.

foldify :: Transducer i o r -> Fold i r

Transforms a Transducer into a Fold by forgetting about the data sent downstream.

foldifyM :: Functor m => TransducerM m i o r -> FoldM m i r

Monadic version of foldify.

hoistTransducer :: Monad m => (forall a. m a -> n a) -> TransducerM m i o r -> TransducerM n i o r

Changes the base monad used by a TransducerM.

hoistFold :: Monad m => (forall a. m a -> n a) -> FoldM m i r -> FoldM n i r

Changes the base monad used by a FoldM.

Re-exports

module Data.Functor.Extend

module Control.Foldl