Fusion

Step

data Step s a r

A simple stepper, as suggested by Duncan Coutts in his Thesis paper, "Stream Fusion: Practical shortcut fusion for coinductive sequence types". This version adds a result type.

Constructors

Done r

Skip s

Yield s a

Instances

Functor (Step s a)

StepList

newtype StepList s r a

Constructors

StepList

Fields

getStepList :: Step s a r

Instances

Functor (StepList s r)

Stream

data Stream a m r where

Constructors

Stream :: (s -> m (Step s a r)) -> m s -> Stream a m r

Instances

MonadTrans (Stream a)

Functor m => Functor (Stream a m)

Monad m => Applicative (Stream a m)

Show a => Show (Stream a Identity r)

mapS :: Functor m => (a -> b) -> Stream a m r -> Stream b m r

Map over the values produced by a stream.

>>> mapS (+1) (fromList [1..3]) :: Stream Int Identity ()
Stream [2,3,4]

concatS :: Monad m => Stream (Stream a m r) m r -> Stream a m r

fromList :: Foldable f => Applicative m => f a -> Stream a m ()

fromListM :: (Monad m, Foldable f) => m (f a) -> Stream a m ()

toListS :: Monad m => Stream a m r -> m [a]

lazyToListS :: Stream a IO r -> IO [a]

runEffect :: Monad m => Stream a m r -> m r

emptyStream :: Monad m => Stream Void m ()

bracketS :: (Monad m, MonadMask m, MonadSafe m) => Base m s -> (s -> Base m ()) -> (forall r. s -> (a -> s -> m r) -> (s -> m r) -> m r -> m r) -> Stream a m ()

next :: Monad m => Stream a m r -> m (Either r (a, Stream a m r))

StreamList

newtype ListT m a

Constructors

ListT

Fields

getListT :: Stream a m ()

Instances

Monad m => Monad (ListT m)

Functor m => Functor (ListT m)

Monad m => Applicative (ListT m)

concat :: Foldable t => t [a] -> [a]

The concatenation of all the elements of a container of lists.

Pipes

type Producer b m r = Stream b m r

type Pipe a b m r = Stream a m () -> Stream b m r

type Consumer a m r = Stream a m () -> m r

each :: (Monad m, Foldable f) => f a -> Producer a m ()

mapP :: Monad m => (a -> b) -> Pipe a b m ()