-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Boozy streaming library
--   
--   Please see the README on Github at
--   <a>https://github.com/fumieval/drinkery#readme</a>
@package drinkery
@version 0.4

module Data.Drinkery.Class

-- | A <a>Sink</a> is a stream consumer monad.
newtype Sink t m a
Sink :: (forall r. t m -> (a -> t m -> m r) -> m r) -> Sink t m a
[unSink] :: Sink t m a -> forall r. t m -> (a -> t m -> m r) -> m r
mapSink :: (forall x. m x -> m x) -> Sink t m a -> Sink t m a
runSink :: Applicative m => Sink t m a -> t m -> m (a, t m)

-- | Monads that drink
class Monad m => MonadSink t m | m -> t
receiving :: MonadSink t m => (forall n. Monad n => t n -> n (a, t n)) -> m a
class CloseRequest a

-- | A value representing a close request
closeRequest :: CloseRequest a => a

-- | Closable tap
class Closable t
close :: (Closable t, Monad m) => t m -> m ()
instance Data.Drinkery.Class.CloseRequest ()
instance Data.Drinkery.Class.CloseRequest a => Data.Drinkery.Class.CloseRequest [a]
instance GHC.Base.Monad m => Data.Drinkery.Class.MonadSink t (Data.Drinkery.Class.Sink t m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.Reader.ReaderT x m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.State.Lazy.StateT x m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.State.Strict.StateT x m)
instance (GHC.Base.Monoid x, Data.Drinkery.Class.MonadSink t m) => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.Writer.Lazy.WriterT x m)
instance (GHC.Base.Monoid x, Data.Drinkery.Class.MonadSink t m) => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.Writer.Strict.WriterT x m)
instance (GHC.Base.Monoid y, Data.Drinkery.Class.MonadSink t m) => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.RWS.Lazy.RWST x y z m)
instance (GHC.Base.Monoid y, Data.Drinkery.Class.MonadSink t m) => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.RWS.Strict.RWST x y z m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.Maybe.MaybeT m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Control.Monad.Trans.Cont.ContT x m)
instance GHC.Base.Functor (Data.Drinkery.Class.Sink s m)
instance GHC.Base.Applicative (Data.Drinkery.Class.Sink s m)
instance GHC.Base.Monad (Data.Drinkery.Class.Sink s m)
instance Control.Monad.Trans.Class.MonadTrans (Data.Drinkery.Class.Sink t)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Drinkery.Class.Sink t m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Data.Drinkery.Class.Sink t m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Data.Drinkery.Class.Sink t m)
instance Control.Monad.Writer.Class.MonadWriter s m => Control.Monad.Writer.Class.MonadWriter s (Data.Drinkery.Class.Sink t m)

module Data.Drinkery.Combinators
foldlFrom' :: (Foldable t, Monad m) => m (t a) -> (b -> a -> b) -> b -> m b
foldMFrom :: (Foldable t, Monad m) => m (t a) -> (b -> a -> m b) -> b -> m b
traverseFrom_ :: (Foldable t, Monad m) => m (t a) -> (a -> m b) -> m ()
drainFrom :: (Foldable t, Monad m) => m (t a) -> m ()
lastFrom :: (Alternative t, Foldable t, Monad m) => m (t a) -> m (Maybe a)

module Data.Drinkery.Tap

-- | <tt><a>Tap</a> m r s</tt> is a non-monadic, endless producer of
--   <tt>s</tt>. It takes a request <tt>r</tt>.
newtype Tap r s m
Tap :: (r -> m (s, Tap r s m)) -> Tap r s m
[unTap] :: Tap r s m -> r -> m (s, Tap r s m)

-- | Prepend a new element, delaying requests.
consTap :: (Semigroup r, Applicative m) => s -> Tap r s m -> Tap r s m

-- | Send a request to a <a>Tap</a>.
orderTap :: Semigroup r => r -> Tap r s m -> Tap r s m

-- | Involve an action.
makeTap :: Monad m => m (Tap r s m) -> Tap r s m
transTap :: Functor n => (forall x. m x -> n x) -> Tap r s m -> Tap r s n
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
unfoldrTapM :: Applicative m => (r -> s -> m (a, s)) -> s -> Tap r a m

-- | (<a>&lt;*&gt;</a>) zips two taps.
newtype Joint r m s
Joint :: Tap r s m -> Joint r m s
[unJoint] :: Joint r m s -> Tap r s m

-- | Monadic producer
newtype Producer r s m a
Producer :: ((a -> Tap r s m) -> Tap r s m) -> Producer r s m a
[unProducer] :: Producer r s m a -> (a -> Tap r s m) -> Tap r s m
yield :: (Semigroup r, Applicative f, Applicative m) => s -> Producer r (f s) m ()

-- | Accept orders and clear the queue.
accept :: Monoid r => Producer r s m r

-- | Create a infinite <a>Tap</a> from a <a>Producer</a>.
--   
--   <pre>
--   inexhaustible :: <a>Producer</a> r s (<a>Sink</a> tap m) x -&gt; <tt>Distiller</tt> tap m r s
--   </pre>
inexhaustible :: Producer r s m x -> Tap r s m

-- | Run a <a>Producer</a> action and terminate the stream with <a>eof</a>.
tapProducer :: (Monoid r, Applicative m) => Producer r (Maybe s) m a -> Tap r (Maybe s) m

-- | Specialised <tt>runProducer</tt>
tapProducer' :: Applicative m => Producer () (Maybe s) m a -> Tap () (Maybe s) m

-- | Produce one element. Orders are put off.
produce :: (Semigroup r, Applicative m) => s -> Producer r s m ()

-- | Backtracking producer a.k.a. "ListT done right".
newtype ListT r m s
ListT :: (forall x. (s -> Tap r x m -> Tap r x m) -> Tap r x m -> Tap r x m) -> ListT r m s
[unListT] :: ListT r m s -> forall x. (s -> Tap r x m -> Tap r x m) -> Tap r x m -> Tap r x m

-- | Take all the elements in a <a>Foldable</a> container.
sample :: Foldable f => f s -> ListT r m s

-- | Get a request.
inquire :: Monoid r => ListT r m r

-- | Run <a>ListT</a> and terminate the stream with <a>eof</a>.
tapListT :: (Semigroup r, Applicative m) => ListT r m s -> Tap r (Maybe s) m

-- | Specialised <tt>runListT</tt>
tapListT' :: Applicative m => ListT () m s -> Tap () (Maybe s) m
retractListT :: Monad m => ListT () m s -> m ()
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 ()

-- | Get one element without consuming.
prefetch :: (Monoid r, Semigroup r, MonadSink (Tap r s) m) => m s

-- | End of stream
eof :: (Applicative m, Alternative f) => Tap r (f a) m
instance GHC.Base.Functor (Data.Drinkery.Tap.ListT r m)
instance GHC.Base.Applicative (Data.Drinkery.Tap.ListT r m)
instance GHC.Base.Monad (Data.Drinkery.Tap.ListT r m)
instance GHC.Base.Alternative (Data.Drinkery.Tap.ListT r m)
instance GHC.Base.MonadPlus (Data.Drinkery.Tap.ListT r m)
instance Control.Monad.Trans.Class.MonadTrans (Data.Drinkery.Tap.ListT r)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Drinkery.Tap.ListT r m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Data.Drinkery.Tap.ListT p m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Data.Drinkery.Tap.ListT p m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Data.Drinkery.Tap.ListT p m)
instance GHC.Base.Functor (Data.Drinkery.Tap.Producer r s m)
instance GHC.Base.Applicative (Data.Drinkery.Tap.Producer r s m)
instance GHC.Base.Monad (Data.Drinkery.Tap.Producer r s m)
instance Control.Monad.Trans.Class.MonadTrans (Data.Drinkery.Tap.Producer r s)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Drinkery.Tap.Producer r s m)
instance Data.Drinkery.Class.MonadSink t m => Data.Drinkery.Class.MonadSink t (Data.Drinkery.Tap.Producer p q m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Data.Drinkery.Tap.Producer p q m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Data.Drinkery.Tap.Producer p q m)
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Drinkery.Tap.Joint r m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Data.Drinkery.Tap.Joint r m)
instance Data.Drinkery.Class.CloseRequest r => Data.Drinkery.Class.Closable (Data.Drinkery.Tap.Tap r s)

module Data.Drinkery.IO

-- | Create a popper from a <a>Tap</a>.
--   
--   <pre>
--   popperTap :: CloseRequest r =&gt; Tap r s IO -&gt; GivesPopper
--   </pre>
popperTap :: (Monoid r, CloseRequest r) => Tap r s IO -> (IO s -> IO ()) -> IO ()

module Data.Drinkery.Distiller

-- | <tt>Distiller tap m r s</tt> is a stream transducer which has four
--   parameters:
--   
--   <ul>
--   <li><tt>tap</tt> input</li>
--   <li><tt>r</tt> request from the downstream</li>
--   <li><tt>s</tt> output</li>
--   <li><tt>m</tt> underlying monad</li>
--   </ul>
--   
--   This is also a <a>Tap</a>.
type Distiller tap r s m = Tap r s (Sink tap m)

-- | Feed a tap to a drinker and close the used tap.
(+&) :: (Closable tap, MonadCatch m) => tap m -> Sink tap m a -> m a
infix 6 +&

-- | Like (<a>+&amp;</a>) but discards the used tap.
--   
--   <pre>
--   ($&amp;) :: Distiller tap m r s -&gt; Sink (Tap r s) (Sink tap m) a -&gt; Sink tap m a
--   </pre>
($&) :: Monad m => tap m -> Sink tap m a -> m a
infixr 7 $&

-- | Attach a distiller to a tap.
--   
--   Mnemonic:
--   
--   <ul>
--   <li><tt>+</tt> Left operand is a tap.</li>
--   <li><tt>+</tt> Returns a tap.</li>
--   <li><tt>$</tt> Right operand is a distiller.</li>
--   </ul>
(++$) :: Applicative m => tap m -> Distiller tap r s m -> Tap r s m
infixl 8 ++$

-- | Connect a tap with a Sink. Flipped <a>runSink</a>.
--   
--   Mnemonic:
--   
--   <ul>
--   <li><tt>+</tt> Left operand is a tap.</li>
--   <li><tt>+</tt> Returns a tap (along with the result).</li>
--   <li><tt>&amp;</tt> Right operand is a Sink.</li>
--   </ul>
(++&) :: Applicative m => tap m -> Sink tap m a -> m (tap m, a)
infixr 7 ++&

-- | Get one element preserving a request
reservingTap :: Monad m => (a -> Sink (Tap r a) m (b, Distiller (Tap r a) r b m)) -> Distiller (Tap r a) r b m
echo :: Monad m => Distiller (Tap r s) r s m
mapping :: Monad m => (a -> b) -> Distiller (Tap r a) r b m
traversing :: Monad m => (a -> m b) -> Distiller (Tap r a) r b m
filtering :: (Monoid r, Monad m) => (a -> Bool) -> Distiller (Tap r a) r a m
scanning :: Monad m => (b -> a -> b) -> b -> Distiller (Tap r a) r b m

-- | Create a request-preserving distiller from a drinker action.
repeating :: (MonadSink (Tap r a) m, Semigroup r) => m b -> Tap r b m

module Data.Drinkery.Finite

-- | Finite source
type Source r s = Tap r (Maybe s)

-- | Mono in/out
type Converter p q r s m = Source r s (Sink (Source p q) m)
type Pipe a b m = forall r. (Monoid r, Semigroup r) => Converter r a r b m
scan :: Monad m => (b -> a -> b) -> b -> Pipe a b m
reserve :: (Monoid r, MonadSink (Source r s) m) => (s -> Producer r (Maybe t) m ()) -> Producer r (Maybe t) m ()
map :: (Functor t, Monad m) => (a -> b) -> Distiller (Tap r (t a)) r (t b) m
map' :: (Functor t, Monad m) => (a -> b) -> Distiller (Tap r (t a)) r (t b) m
concatMap :: (Foldable f, Monad m) => (a -> f b) -> Pipe a b m
filter :: Monad m => (a -> Bool) -> Pipe a a m
mapAccum :: Monad m => (s -> a -> (s, b)) -> s -> Pipe a b m
traverse :: Monad m => (a -> m b) -> Pipe a b m
take :: Monad m => Int -> Pipe a a m
drop :: Monad m => Int -> Pipe a a m
takeWhile :: Monad m => (a -> Bool) -> Pipe a a m
dropWhile :: Monad m => (a -> Bool) -> Pipe a a m

-- | Consume all the content of a <a>Tap</a> and return the elements as a
--   list.
drinkUp :: (Monoid r, Semigroup r, MonadSink (Tap r (Maybe s)) m) => m [s]

module Data.Drinkery.Awaiter

-- | <tt>Awaiter s</tt> is a simple consumer of <tt>s</tt>. Unlike
--   <a>Sink</a>, it can be partially run.
--   
--   <tt>serving</tt> distributes each input to a list of <a>Awaiter</a>s
--   until all the patrons terminate. (<a>&lt;|&gt;</a>) returns the first
--   result.
newtype Awaiter s m a
Awaiter :: m (Either (s -> Awaiter s m a) a) -> Awaiter s m a
[runAwaiter] :: Awaiter s m a -> m (Either (s -> Awaiter s m a) a)
await :: Monad m => Awaiter s m s
serving_ :: Monad m => [Awaiter s m a] -> Awaiter s m ()
iterAwaiter :: Monad m => m s -> Awaiter s m a -> m a

-- | <pre>
--   iterAwaiterT consume :: Awaiter s m a -&gt; Sink s m a
--   </pre>
iterAwaiterT :: (Monad m, MonadTrans t, Monad (t m)) => t m s -> Awaiter s m a -> t m a
lookAheadT :: (Monad m, MonadTrans t, Monoid r, Semigroup r, MonadSink (Tap r s) (t m)) => Awaiter s m a -> t m a
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Drinkery.Awaiter.Awaiter s m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Data.Drinkery.Awaiter.Awaiter s m)
instance GHC.Base.Monad m => GHC.Base.Monad (Data.Drinkery.Awaiter.Awaiter s m)
instance Control.Monad.Trans.Class.MonadTrans (Data.Drinkery.Awaiter.Awaiter s)
instance GHC.Base.Monad m => GHC.Base.Alternative (Data.Drinkery.Awaiter.Awaiter s m)
instance GHC.Base.Monad m => GHC.Base.MonadPlus (Data.Drinkery.Awaiter.Awaiter s m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Drinkery.Awaiter.Awaiter s m)

module Data.Drinkery
