Data.SouSiT

Sink

data Sink i m r

Instances

Monad m => Monad (Sink i m)

Monad m => Functor (Sink i m)

(Functor (Sink i m), Monad m) => Applicative (Sink i m)

type Fetch i a = Sink i Identity a

input :: Monad m => Sink a m a

Reads the next element. The sink returns a fail if it is closed before the input is received.

inputOr :: Monad m => m a -> Sink a m a

Reads the next element. If the sink is closed while waiting for the input, then the parameter is returned as the sinks result.

inputMap :: Monad m => (a -> m b) -> m b -> Sink a m b

Reads the next element. Returns (Just a) for the element or Nothing if the sink is closed before the input was available.

inputMaybe :: Monad m => Sink a m (Maybe a)

Reads the next element. Returns (Just a) for the element or Nothing if the sink is closed before the input was available.

skip :: (Eq n, Num n, Monad m) => n -> Sink a m ()

Skips n input elements. If the sink is closed before then the result will also be ().

liftSink :: (Monad m, Monad m') => (forall x. m x -> m' x) -> Sink i m r -> Sink i m' r

Changes the monad of a sink based upon a conversion function that maps the original monad to the new one.

liftFetch :: Monad m => Fetch i a -> Sink i m a

Lift the (pure) fetch sink into any monad.

Source

class Source src where

Something that produces data to be processed by a sink

Methods

transfer :: Monad m => src m a -> Sink a m r -> m r

Instances

Source FeedSource

Source SimpleSource

data FeedSource m a

A basic instance of FeedSource (and Source)

Instances

Source FeedSource

data SimpleSource m a

A basic instance of Source

Constructors

SimpleSource (forall r. Sink a m r -> m r)

Instances

Source SimpleSource

feedToSink :: FeedSource m a -> forall r. Sink a m r -> m (Sink a m r)

($$) :: (Source src, Monad m) => src m a -> Sink a m r -> m r

Transfer the data from the source into the sink

(=+=) :: Monad m => FeedSource m a -> FeedSource m a -> FeedSource m a

Concatenates two sources.

(=+|=) :: (Source src2, Monad m) => FeedSource m a -> src2 m a -> SimpleSource m a

Concatenates two sources.

Transform

type Transform a b = forall m r. Monad m => Sink b m r -> Sink a m r

(=$=) :: Monad m => (Sink b m r -> Sink a m r) -> (Sink c m r -> Sink b m r) -> Sink c m r -> Sink a m r

Merges two transforms into one.

(=$) :: Monad m => (Sink b m r -> Sink a m r) -> Sink b m r -> Sink a m r

Apply a transform to a sink.

($=) :: (Source src, Monad m) => src m a -> (forall r. Sink b m r -> Sink a m r) -> SimpleSource m b

Apply a transform to a source.