Streaming.Eversion

The pull-to-push transformations in this module require functions that are polymorphic over a monad transformer.

Because of this, some of the type signatures look scary, but actually many (suitably polymorphic) operations on Streams will unify with them.

To get "interruptible" operations that can exit early with an error, put a ExceptT transformer just below the polymorphic monad transformer. See foldE.

Inspired by http://pchiusano.blogspot.com.es/2011/12/programmatic-translation-to-iteratees.html

Evertible Stream folds

data Evertible a x

A stream-consuming function that can be turned into a pure, push-based fold.

Instances

Profunctor Evertible

Methods

dimap :: (a -> b) -> (c -> d) -> Evertible b c -> Evertible a d

lmap :: (a -> b) -> Evertible b c -> Evertible a c

rmap :: (b -> c) -> Evertible a b -> Evertible a c

(#.) :: Coercible * c b => (b -> c) -> Evertible a b -> Evertible a c

(.#) :: Coercible * b a => Evertible b c -> (a -> b) -> Evertible a c

Functor (Evertible a)

Methods

fmap :: (a -> b) -> Evertible a a -> Evertible a b

(<$) :: a -> Evertible a b -> Evertible a a

evertible :: (forall m r. Monad m => Stream (Of a) m r -> m (Of x r)) -> Evertible a x

evert :: Evertible a x -> Fold a x

data EvertibleM m a x

Like Evertible, but gives the stream-consuming function access to a base monad.

>>> :{
    let f stream = fmap ((:>) ()) (lift (putStrLn "x") >> S.effects stream)
    in  L.foldM (evertM (evertibleM f)) ["a","b","c"]
    :}
x

Note however that control operations can't be lifted through the transformer.

Instances

Profunctor (EvertibleM m)

Methods

dimap :: (a -> b) -> (c -> d) -> EvertibleM m b c -> EvertibleM m a d

lmap :: (a -> b) -> EvertibleM m b c -> EvertibleM m a c

rmap :: (b -> c) -> EvertibleM m a b -> EvertibleM m a c

(#.) :: Coercible * c b => (b -> c) -> EvertibleM m a b -> EvertibleM m a c

(.#) :: Coercible * b a => EvertibleM m b c -> (a -> b) -> EvertibleM m a c

Functor (EvertibleM m a)

Methods

fmap :: (a -> b) -> EvertibleM m a a -> EvertibleM m a b

(<$) :: a -> EvertibleM m a b -> EvertibleM m a a

evertibleM

Arguments

:: (forall t r. (MonadTrans t, Monad (t m)) => Stream (Of a) (t m) r -> t m (Of x r))

-> EvertibleM m a x

evertM :: Monad m => EvertibleM m a x -> FoldM m a x

data EvertibleMIO m a x

Like EvertibleM, but gives the stream-consuming function the ability to use liftIO.

>>> L.foldM (evertMIO (evertibleMIO (\stream -> fmap ((:>) ()) (S.print stream)))) ["a","b","c"]
"a"
"b"
"c"

Instances

Profunctor (EvertibleMIO m)

Methods

dimap :: (a -> b) -> (c -> d) -> EvertibleMIO m b c -> EvertibleMIO m a d

lmap :: (a -> b) -> EvertibleMIO m b c -> EvertibleMIO m a c

rmap :: (b -> c) -> EvertibleMIO m a b -> EvertibleMIO m a c

(#.) :: Coercible * c b => (b -> c) -> EvertibleMIO m a b -> EvertibleMIO m a c

(.#) :: Coercible * b a => EvertibleMIO m b c -> (a -> b) -> EvertibleMIO m a c

Functor (EvertibleMIO m a)

Methods

fmap :: (a -> b) -> EvertibleMIO m a a -> EvertibleMIO m a b

(<$) :: a -> EvertibleMIO m a b -> EvertibleMIO m a a

evertibleMIO

Arguments

:: (forall t r. (MonadTrans t, MonadIO (t m)) => Stream (Of a) (t m) r -> t m (Of x r))

-> EvertibleMIO m a x

evertMIO :: MonadIO m => EvertibleMIO m a x -> FoldM m a x

Transvertible Stream transformations

data Transvertible a b

A stream-transforming function that can be turned into fold-transforming function.

Instances

Profunctor Transvertible

Methods

dimap :: (a -> b) -> (c -> d) -> Transvertible b c -> Transvertible a d

lmap :: (a -> b) -> Transvertible b c -> Transvertible a c

rmap :: (b -> c) -> Transvertible a b -> Transvertible a c

(#.) :: Coercible * c b => (b -> c) -> Transvertible a b -> Transvertible a c

(.#) :: Coercible * b a => Transvertible b c -> (a -> b) -> Transvertible a c

Functor (Transvertible a)

Methods

fmap :: (a -> b) -> Transvertible a a -> Transvertible a b

(<$) :: a -> Transvertible a b -> Transvertible a a

transvertible

Arguments

:: (forall m r. Monad m => Stream (Of a) m r -> Stream (Of b) m r)

-> Transvertible a b

transvert :: Transvertible b a -> forall x. Fold a x -> Fold b x

data TransvertibleM m a b

Like Transvertible, but gives the stream-transforming function access to a base monad.

Note however that control operations can't be lifted through the transformer.

Instances

Profunctor (TransvertibleM m)

Methods

dimap :: (a -> b) -> (c -> d) -> TransvertibleM m b c -> TransvertibleM m a d

lmap :: (a -> b) -> TransvertibleM m b c -> TransvertibleM m a c

rmap :: (b -> c) -> TransvertibleM m a b -> TransvertibleM m a c

(#.) :: Coercible * c b => (b -> c) -> TransvertibleM m a b -> TransvertibleM m a c

(.#) :: Coercible * b a => TransvertibleM m b c -> (a -> b) -> TransvertibleM m a c

Functor (TransvertibleM m a)

Methods

fmap :: (a -> b) -> TransvertibleM m a a -> TransvertibleM m a b

(<$) :: a -> TransvertibleM m a b -> TransvertibleM m a a

transvertibleM

Arguments

:: (forall t r. (MonadTrans t, Monad (t m)) => Stream (Of a) (t m) r -> Stream (Of b) (t m) r)

-> TransvertibleM m a b

transvertM :: Monad m => TransvertibleM m b a -> forall x. FoldM m a x -> FoldM m b x

data TransvertibleMIO m a b

Like TransvertibleM, but gives the stream-consuming function the ability to use liftIO.

Instances

Profunctor (TransvertibleMIO m)

Methods

dimap :: (a -> b) -> (c -> d) -> TransvertibleMIO m b c -> TransvertibleMIO m a d

lmap :: (a -> b) -> TransvertibleMIO m b c -> TransvertibleMIO m a c

rmap :: (b -> c) -> TransvertibleMIO m a b -> TransvertibleMIO m a c

(#.) :: Coercible * c b => (b -> c) -> TransvertibleMIO m a b -> TransvertibleMIO m a c

(.#) :: Coercible * b a => TransvertibleMIO m b c -> (a -> b) -> TransvertibleMIO m a c

Functor (TransvertibleMIO m a)

Methods

fmap :: (a -> b) -> TransvertibleMIO m a a -> TransvertibleMIO m a b

(<$) :: a -> TransvertibleMIO m a b -> TransvertibleMIO m a a

transvertibleMIO

Arguments

:: (forall t r. (MonadTrans t, MonadIO (t m)) => Stream (Of a) (t m) r -> Stream (Of b) (t m) r)

-> TransvertibleMIO m a b

transvertMIO :: MonadIO m => TransvertibleMIO m b a -> forall x. FoldM m a x -> FoldM m b x

Auxiliary functions

foldE

Arguments

:: (MonadTrans t, Monad m, Monad (t (ExceptT e m)))

=> t (ExceptT e m) (Either e r)

-> t (ExceptT e m) r

If your stream-folding computation can fail early returning a Left, compose it with this function before passing it to evertibleM.

The result will be an EvertibleM that works on ExceptT.

>>> runExceptT $ L.foldM (evertM (evertibleM (foldE . (\_ -> return (Left ()))))) [1..10]
Left ()