Data.Drinkery.Tap

Tap

newtype Tap r s m

Tap m r s is a non-monadic, endless producer of s. It takes a request r.

Constructors

Tap

Fields

• unTap :: r -> m (s, Tap r s m)

Instances

CloseRequest r => Closable (Tap r s)

Methods

close :: Monad m => Tap r s m -> m ()

consTap :: (Semigroup r, Applicative m) => s -> Tap r s m -> Tap r s m

Prepend a new element, delaying requests.

orderTap :: Semigroup r => r -> Tap r s m -> Tap r s m

Send a request to a Tap.

makeTap :: Monad m => m (Tap r s m) -> Tap r s m

Involve an action.

repeatTap :: Applicative m => s -> Tap r s m

repeatTapM :: Applicative m => m s -> Tap r s m

repeatTapM' :: Applicative m => m s -> Tap () s m

newtype Joint r m s

(<*>) zips two taps.

Constructors

Joint

Fields

• unJoint :: Tap r s m

Instances

Functor m => Functor (Joint r m)

Methods

fmap :: (a -> b) -> Joint r m a -> Joint r m b

(<$) :: a -> Joint r m b -> Joint r m a

Applicative m => Applicative (Joint r m)

Methods

pure :: a -> Joint r m a

(<*>) :: Joint r m (a -> b) -> Joint r m a -> Joint r m b

liftA2 :: (a -> b -> c) -> Joint r m a -> Joint r m b -> Joint r m c

(*>) :: Joint r m a -> Joint r m b -> Joint r m b

(<*) :: Joint r m a -> Joint r m b -> Joint r m a

Producer

newtype Producer r s m a

Monadic producer

Constructors

Producer

Fields

• unProducer :: (a -> Tap r s m) -> Tap r s m

Instances

MonadSink t m => MonadSink t (Producer p q m)

Methods

receiving :: (forall (n :: * -> *). Monad n => t n -> n (a, t n)) -> Producer p q m a

MonadTrans (Producer r s)

Methods

lift :: Monad m => m a -> Producer r s m a

Monad (Producer r s m)

Methods

(>>=) :: Producer r s m a -> (a -> Producer r s m b) -> Producer r s m b

(>>) :: Producer r s m a -> Producer r s m b -> Producer r s m b

return :: a -> Producer r s m a

fail :: String -> Producer r s m a

Functor (Producer r s m)

Methods

fmap :: (a -> b) -> Producer r s m a -> Producer r s m b

(<$) :: a -> Producer r s m b -> Producer r s m a

Applicative (Producer r s m)

Methods

pure :: a -> Producer r s m a

(<*>) :: Producer r s m (a -> b) -> Producer r s m a -> Producer r s m b

liftA2 :: (a -> b -> c) -> Producer r s m a -> Producer r s m b -> Producer r s m c

(*>) :: Producer r s m a -> Producer r s m b -> Producer r s m b

(<*) :: Producer r s m a -> Producer r s m b -> Producer r s m a

MonadIO m => MonadIO (Producer r s m)

Methods

liftIO :: IO a -> Producer r s m a

yield :: (Semigroup r, Applicative f, Applicative m) => s -> Producer r (f s) m ()

accept :: Monoid r => Producer r s m r

Accept orders and clear the queue.

inexhaustible :: Producer r s m x -> Tap r s m

Create a infinite Tap from a Producer.

inexhaustible :: Producer r s (Sink tap m) x -> Distiller tap m r s

tapProducer :: (Monoid r, Applicative m, Alternative f) => Producer r (f s) m a -> Tap r (f s) m

Run a Producer action and terminate the stream with eof.

tapProducer' :: (Applicative m, Alternative f) => Producer () (f s) m a -> Tap () (f s) m

Specialised runProducer

produce :: (Semigroup r, Applicative m) => s -> Producer r s m ()

Produce one element. Orders are put off.

ListT

newtype ListT r m s

Backtracking producer a.k.a. "ListT done right".

Constructors

ListT

Fields

• unListT :: forall x. (s -> Tap r x m -> Tap r x m) -> Tap r x m -> Tap r x m

Instances

MonadSink t m => MonadSink t (ListT p m)

Methods

receiving :: (forall (n :: * -> *). Monad n => t n -> n (a, t n)) -> ListT p m a

MonadTrans (ListT r)

Methods

lift :: Monad m => m a -> ListT r m a

Monad (ListT r m)

Methods

(>>=) :: ListT r m a -> (a -> ListT r m b) -> ListT r m b

(>>) :: ListT r m a -> ListT r m b -> ListT r m b

return :: a -> ListT r m a

fail :: String -> ListT r m a

Functor (ListT r m)

Methods

fmap :: (a -> b) -> ListT r m a -> ListT r m b

(<$) :: a -> ListT r m b -> ListT r m a

Applicative (ListT r m)

Methods

pure :: a -> ListT r m a

(<*>) :: ListT r m (a -> b) -> ListT r m a -> ListT r m b

liftA2 :: (a -> b -> c) -> ListT r m a -> ListT r m b -> ListT r m c

(*>) :: ListT r m a -> ListT r m b -> ListT r m b

(<*) :: ListT r m a -> ListT r m b -> ListT r m a

MonadIO m => MonadIO (ListT r m)

Methods

liftIO :: IO a -> ListT r m a

Alternative (ListT r m)

Methods

empty :: ListT r m a

(<|>) :: ListT r m a -> ListT r m a -> ListT r m a

some :: ListT r m a -> ListT r m [a]

many :: ListT r m a -> ListT r m [a]

MonadPlus (ListT r m)

Methods

mzero :: ListT r m a

mplus :: ListT r m a -> ListT r m a -> ListT r m a

sample :: Foldable f => f s -> ListT r m s

Take all the elements in a Foldable container.

inquire :: Monoid r => ListT r m r

Get a request.

tapListT :: (Semigroup r, Applicative m, Alternative f) => ListT r m s -> Tap r (f s) m

Run ListT and terminate the stream with eof.

tapListT' :: (Applicative m, Alternative f) => ListT () m s -> Tap () (f s) m

Specialised runListT

retractListT :: Monad m => ListT () m s -> m ()

Sink

consume :: (Monoid r, MonadSink (Tap r s) m) => m s

leftover :: (Semigroup r, MonadSink (Tap r s) m) => s -> m ()

request :: (Semigroup r, MonadSink (Tap r s) m) => r -> m ()

prefetch :: (Monoid r, Semigroup r, MonadSink (Tap r s) m) => m s

Get one element without consuming.

End of stream

eof :: (Applicative m, Alternative f) => Tap r (f a) m

End of stream