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


-- | The Bluefin effect system
--   
--   The Bluefin effect system
@package bluefin
@version 0.7.0.1

module Bluefin

module Bluefin.Capability

module Bluefin.Capability.Ask
type Ask = Reader
runAsk :: forall r (es :: Effects) a. r -> (forall (e :: Effects). () => Ask r e -> Eff (e :& es) a) -> Eff es a
ask :: forall (e :: Effects) (es :: Effects) r. e <: es => Reader r e -> Eff es r
asks :: forall (e :: Effects) (es :: Effects) r a. e <: es => Reader r e -> (r -> a) -> Eff es a
local :: forall (e1 :: Effects) (es :: Effects) r a. e1 <: es => Reader r e1 -> (r -> r) -> Eff es a -> Eff es a


-- | <a>AskCapability</a> is like <a>Ask</a>, generalized to work for
--   arbitrary <a>Handle</a>s. <a>localCapability</a> locally overrides the
--   value of a capability in a well-scoped way. The original capability
--   will be restored when you exit the <tt>localCapability</tt> block
--   regardless of whether the exit was normal or via an exception.
--   
--   <tt>AskCapability</tt> supports functionality similiar to
--   <tt>effectful</tt>'s <a><tt>interpose</tt></a> and <tt>polysemy</tt>'s
--   <a><tt>intercept</tt></a>, that is, locally augmenting an effect with
--   new behaviors. If you want to do the same in Bluefin you may want to
--   start with <tt>Bluefin.GadtEffect.<a>interpose</a></tt>.
module Bluefin.Capability.AskCapability
type AskCapability = HandleReader
runAskCapability :: forall (e1 :: Effects) (es :: Effects) h r. (e1 <: es, Handle h) => h e1 -> (forall (e :: Effects). () => HandleReader h e -> Eff (e :& es) r) -> Eff es r
askCapability :: forall (e :: Effects) (es :: Effects) h. (e <: es, Handle h) => HandleReader h e -> Eff es (h es)
asksCapability :: forall (e1 :: Effects) (es :: Effects) h r. (e1 <: es, Handle h) => AskCapability h e1 -> (forall (e :: Effects). () => h e -> Eff (e :& es) r) -> Eff es r
localCapability :: forall (e :: Effects) (es :: Effects) h r. (e <: es, Handle h) => AskCapability h e -> (h es -> h es) -> Eff es r -> Eff es r

module Bluefin.Capability.Await
type Await a = Consume a
eachAwait :: forall b (es :: Effects) r. (forall (e :: Effects). () => Await b e -> Eff (e :& es) r) -> Eff es b -> Eff es r
awaitYield :: forall a (es :: Effects) r. (forall (e :: Effects). () => Await a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Yield a e -> Eff (e :& es) r) -> Eff es r
await :: forall (e :: Effects) (es :: Effects) a. e <: es => Consume a e -> Eff es a
takeAwait :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es) => Int -> Await a e1 -> Yield a e2 -> Eff es ()

module Bluefin.Capability.JumpTo
type JumpTo = Jump
withJumpTo :: forall (es :: Effects). (forall (e :: Effects). () => JumpTo e -> Eff (e :& es) ()) -> Eff es ()
jumpTo :: forall (e :: Effects) (es :: Effects) a. e <: es => Jump e -> Eff es a

module Bluefin.Capability.Modify
type Modify = State
evalModify :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => Modify s e -> Eff (e :& es) a) -> Eff es a
runModify :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => Modify s e -> Eff (e :& es) a) -> Eff es (a, s)
withModify :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => Modify s e -> Eff (e :& es) (s -> a)) -> Eff es a
get :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> Eff es s
put :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> s -> Eff es ()
modify :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> (s -> s) -> Eff es ()

module Bluefin.Capability.Request
type Request = Coroutine
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
connectRequests :: forall (es :: Effects) a b r. (forall (e :: Effects). () => Request a b e -> Eff (e :& es) r) -> (forall (e :: Effects). () => a -> Request b a e -> Eff (e :& es) r) -> Eff es r
request :: forall (e1 :: Effects) (es :: Effects) a b. e1 <: es => Request a b e1 -> a -> Eff es b

module Bluefin.Capability.ReturnEarly
type ReturnEarly = EarlyReturn
withReturnEarly :: forall r (es :: Effects). (forall (e :: Effects). () => EarlyReturn r e -> Eff (e :& es) r) -> Eff es r
returnEarly :: forall (e :: Effects) (es :: Effects) r a. e <: es => EarlyReturn r e -> r -> Eff es a

module Bluefin.Capability.Tell
type Tell = Writer
runTell :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Tell w e -> Eff (e :& es) r) -> Eff es (r, w)
execTell :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Tell w e -> Eff (e :& es) r) -> Eff es w
tell :: forall (e :: Effects) (es :: Effects) w. e <: es => Writer w e -> w -> Eff es ()

module Bluefin.Capability.Throw
type Throw = Exception
try :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es (Either exn a)
handle :: forall exn (es :: Effects) a. (exn -> Eff es a) -> (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es a
catch :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> (exn -> Eff es a) -> Eff es a
throw :: forall (e :: Effects) (es :: Effects) ex a. e <: es => Exception ex e -> ex -> Eff es a
rethrowIO :: forall ex (es :: Effects) (e1 :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es, Exception ex) => IOE e1 -> Exception ex e2 -> Eff es r -> Eff es r

module Bluefin.Capability.Yield
type Yield a = Stream a
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
yieldToList :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)
yieldToReverseList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> Eff es ([a], r)
withYieldToList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) ([a] -> r)) -> Eff es r
ignoreYield :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es r
enumerate :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r
enumerateFrom :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => Int -> (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r
mapMaybe :: forall (e2 :: Effects) (es :: Effects) a b r. e2 <: es => (a -> Maybe b) -> (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream b e2 -> Eff es r
catMaybes :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Stream (Maybe a) e1 -> Eff (e1 :& es) r) -> Stream a e2 -> Eff es r
awaitYield :: forall a (es :: Effects) r. (forall (e :: Effects). () => Await a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Yield a e -> Eff (e :& es) r) -> Eff es r
yield :: forall (e1 :: Effects) (es :: Effects) a. e1 <: es => Stream a e1 -> a -> Eff es ()
inFoldable :: forall t (e1 :: Effects) (es :: Effects) a. (Foldable t, e1 <: es) => t a -> Stream a e1 -> Eff es ()
cycleToYield :: forall f (e1 :: Effects) (es :: Effects) a. (Foldable f, e1 <: es) => f a -> Yield a e1 -> Eff es ()
takeAwait :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es) => Int -> Await a e1 -> Yield a e2 -> Eff es ()


-- | <tt>Bluefin.CloneableHandle</tt> defines the <a>CloneableHandle</a>
--   class, whose purpose is to support <a>withEffToIOCloneHandle</a>.
module Bluefin.CloneableHandle
withEffToIOCloneHandle :: forall (e1 :: Effects) (es :: Effects) h a. (e1 <: es, CloneableHandle h) => IOE e1 -> h es -> ((forall r. () => (forall (e :: Effects). () => IOE e -> h e -> Eff e r) -> IO r) -> IO a) -> Eff es a
class Handle h => CloneableHandle (h :: Effects -> Type)
newtype () => GenericCloneableHandle (h :: k -> Type) (e :: k)
MkGenericCloneableHandle :: h e -> GenericCloneableHandle (h :: k -> Type) (e :: k)
class Handle h => GCloneableHandle (h :: Effects -> Type)
class () => Generic1 (f :: k -> Type)

module Bluefin.Compound
class () => Handle (h :: Effects -> Type)
handleImpl :: Handle h => HandleD h
data () => HandleD (h :: Effects -> Type)
mapHandle :: forall h (e :: Effects) (es :: Effects). (Handle h, e <: es) => h e -> h es
class () => OneWayCoercible (a :: k) (b :: k)
oneWayCoercibleImpl :: OneWayCoercible a b => OneWayCoercibleD a b
newtype () => OneWayCoercibleHandle (a :: k -> Type) (es :: k)
MkOneWayCoercibleHandle :: a es -> OneWayCoercibleHandle (a :: k -> Type) (es :: k)
handleOneWayCoercible :: forall (h :: Effects -> Type). (forall (e :: Effects) (es :: Effects). e <: es => OneWayCoercible (h e) (h es)) => HandleD h
withHandle :: Handle h => ((forall (e :: Effects) (es :: Effects). e <: es => OneWayCoercible (h e) (h es)) => r) -> r
gOneWayCoercible :: forall {k} h (e :: k) (es :: k). GOneWayCoercible (Rep (h e)) (Rep (h es)) => OneWayCoercibleD (h e) (h es)
oneWayCoercibleTrustMe :: forall (e :: Effects) (es :: Effects) h. e <: es => (forall (e' :: Effects) (es' :: Effects). e' <: es' => h e' -> h es') -> OneWayCoercibleD (h e) (h es)
class () => Generic a
makeOp :: forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
useImpl :: forall (e :: Effects) (es :: Effects) r. e <: es => Eff e r -> Eff es r
useImplUnder :: forall (e :: Effects) (es :: Effects) (e1 :: Effects) r. e <: es => Eff (e1 :& e) r -> Eff (e1 :& es) r
useImplIn :: forall (e :: Effects) (es :: Effects) t r. e <: es => (t -> Eff (es :& e) r) -> t -> Eff es r
data () => Compound (e1 :: Effects -> Type) (e2 :: Effects -> Type) (ss :: Effects)
runCompound :: forall e1 (s1 :: Effects) e2 (s2 :: Effects) (es :: Effects) r. e1 s1 -> e2 s2 -> (forall (es' :: Effects). () => Compound e1 e2 es' -> Eff (es' :& es) r) -> Eff (s1 :& (s2 :& es)) r
withCompound :: forall h1 h2 (e :: Effects) (es :: Effects) r. e <: es => Compound h1 h2 e -> (forall (e1 :: Effects) (e2 :: Effects). (e1 <: es, e2 <: es) => h1 e1 -> h2 e2 -> Eff es r) -> Eff es r
useImplWithin :: forall (e :: Effects) (es :: Effects) t (e1 :: Effects) r. e <: es => (t -> Eff (e1 :& e) r) -> t -> Eff (e1 :& es) r


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Await</a> instead.
module Bluefin.Consume
type Consume a = Coroutine () a
consumeEach :: forall b (es :: Effects) r. (forall (e :: Effects). () => Consume b e -> Eff (e :& es) r) -> Eff es b -> Eff es r
consumeStream :: forall a (es :: Effects) r. (forall (e :: Effects). () => Consume a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> Eff es r
streamConsume :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Consume a e -> Eff (e :& es) r) -> Eff es r
await :: forall (e :: Effects) (es :: Effects) a. e <: es => Consume a e -> Eff es a
takeConsume :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es) => Int -> Consume a e1 -> Stream a e2 -> Eff es ()


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Request</a> instead.
module Bluefin.Coroutine
data () => Coroutine a b (e :: Effects)
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
connectCoroutines :: forall (es :: Effects) a b r. (forall (e :: Effects). () => Coroutine a b e -> Eff (e :& es) r) -> (forall (e :: Effects). () => a -> Coroutine b a e -> Eff (e :& es) r) -> Eff es r
yieldCoroutine :: forall (e1 :: Effects) (es :: Effects) a b. e1 <: es => Coroutine a b e1 -> a -> Eff es b

module Bluefin.DslBuilder
data () => DslBuilder (h :: Effects -> Type) r
dslBuilder :: (forall (e :: Effects). () => h e -> Eff e r) -> DslBuilder h r
runDslBuilder :: forall h (es :: Effects) r. Handle h => h es -> DslBuilder h r -> Eff es r


-- | Like <a>Bluefin.DslBuilder</a>, but when you want to be able to run
--   additional effects as well.
module Bluefin.DslBuilderEff
data () => DslBuilderEff (h :: Effects -> Type) (es :: Effects) r
dslBuilderEff :: forall h (es :: Effects) r. (forall (e :: Effects). () => h e -> Eff (e :& es) r) -> DslBuilderEff h es r
runDslBuilderEff :: forall h (es :: Effects) r. h es -> DslBuilderEff h es r -> Eff es r


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.ReturnEarly</a> instead.
module Bluefin.EarlyReturn
type EarlyReturn = Exception
withEarlyReturn :: forall r (es :: Effects). (forall (e :: Effects). () => EarlyReturn r e -> Eff (e :& es) r) -> Eff es r
returnEarly :: forall (e :: Effects) (es :: Effects) r a. e <: es => EarlyReturn r e -> r -> Eff es a

module Bluefin.Eff
data () => Eff (es :: Effects) a
runPureEff :: (forall (es :: Effects). () => Eff es a) -> a
runEff :: (forall (e :: Effects). () => IOE e -> Eff e a) -> IO a
bracket :: forall (es :: Effects) a b. Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
finally :: forall (es :: Effects) b. Eff es b -> Eff es () -> Eff es b
withMonadIO :: forall (e :: Effects) (es :: Effects) r. e <: es => IOE e -> (forall (m :: Type -> Type). MonadIO m => m r) -> Eff es r
withMonadFail :: forall (e :: Effects) (es :: Effects) r. e <: es => Exception String e -> (forall (m :: Type -> Type). MonadFail m => m r) -> Eff es r
data () => Effects
class () => (es1 :: Effects) :> (es2 :: Effects)
type (<:) = (:>)
type (:&) = 'Union
runEff_ :: (forall (e :: Effects). () => IOE e -> Eff e a) -> IO a


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Throw</a> instead.
module Bluefin.Exception
data () => Exception exn (e :: Effects)
try :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es (Either exn a)
handle :: forall exn (es :: Effects) a. (exn -> Eff es a) -> (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es a
catch :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> (exn -> Eff es a) -> Eff es a
throw :: forall (e :: Effects) (es :: Effects) ex a. e <: es => Exception ex e -> ex -> Eff es a
rethrowIO :: forall ex (es :: Effects) (e1 :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es, Exception ex) => IOE e1 -> Exception ex e2 -> Eff es r -> Eff es r

module Bluefin.Exception.GeneralBracket
generalBracket :: forall r b h a (es :: Effects). Handle h => Eff es r -> MakeExceptions r a h es -> (r -> b -> Eff es a) -> (r -> Eff es ()) -> (forall (e :: Effects). () => h e -> r -> Eff (e :& es) b) -> Eff es a
data () => MakeExceptions r a (h :: Effects -> Type) (es :: Effects)
catchWithResource :: forall ex r a (es :: Effects). (r -> ex -> Eff es a) -> MakeExceptions r a (Exception ex) es
pureMakeExceptions :: forall h (e :: Effects) r a. h e -> MakeExceptions r a h e
apMakeExceptions :: forall (h1 :: Effects -> Type) (h2 :: Effects -> Type) r a (e :: Effects). (Handle h1, Handle h2) => MakeExceptions r a (h1 :~> h2) e -> MakeExceptions r a h1 e -> MakeExceptions r a h2 e
fmapMakeExceptions :: forall (h1 :: Effects -> Type) (h2 :: Effects -> Type) (e :: Effects) r a. (Handle h1, Handle h2) => (h1 :~> h2) e -> MakeExceptions r a h1 e -> MakeExceptions r a h2 e
data () => ( (h1 :: Effects -> Type) :~> (h2 :: Effects -> Type) ) (es :: Effects)
abstract :: forall h2 h1 (es :: Effects). Handle h2 => (forall (e :: Effects). () => h1 e -> h2 (e :& es)) -> (h1 :~> h2) es

module Bluefin.GadtEffect
data () => Send (f :: Effect) (e :: Effects)
send :: forall (e1 :: Effects) (es :: Effects) f r. e1 <: es => Send f e1 -> f (Eff es) r -> Eff es r
passthrough :: forall f r (e1 :: Effects) (es :: Effects) (e2 :: Effects). (Handle (GadtEffect f r), e1 <: es, e2 <: es) => Send f e1 -> f (Eff e2) r -> Eff es r
type EffectHandler (f :: Type -> Type -> Type -> Type) (es :: Effects) = forall (e :: Effects) r. () => f Eff e r -> Eff e :& es r
interpret :: forall (f :: (Type -> Type) -> Type -> Type) (es :: Effects) r. EffectHandler f es -> (forall (e :: Effects). () => Send f e -> Eff (e :& es) r) -> Eff es r
interpose :: forall (e1 :: Effects) (es :: Effects) (f :: Effect) r. e1 <: es => (Send f es -> EffectHandler f es) -> HandleReader (Send f) e1 -> Eff es r -> Eff es r
type Effect = Type -> Type -> Type -> Type
data () => GadtEffect (f :: Type -> Type -> Type -> Type) a (e :: Effects)
oneWayCoercibleGadtEffectTrustMe :: forall (e :: Effects) (es :: Effects) f r. e <: es => (forall (e' :: Effects) (es' :: Effects). e' <: es' => f (Eff e') r -> f (Eff es') r) -> OneWayCoercibleD (GadtEffect f r e) (GadtEffect f r es)


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.AskCapability</a> instead.
--   
--   <a>HandleReader</a> is like <a>Reader</a>, generalized to work for
--   arbitrary <a>Handle</a>s. <a>localHandle</a> locally overrides the
--   value of a capability in a well-scoped way. The original capability
--   will be restored when you exit the <tt>localHandle</tt> block
--   regardless of whether the exit was normal or via an exception.
--   
--   <tt>HandleReader</tt> supports functionality similiar to
--   <tt>effectful</tt>'s <a><tt>interpose</tt></a> and <tt>polysemy</tt>'s
--   <a><tt>intercept</tt></a>, that is, locally augmenting an effect with
--   new behaviors. If you want to do the same in Bluefin you may want to
--   start with <tt>Bluefin.GadtEffect.<a>interpose</a></tt>.
module Bluefin.HandleReader
data () => HandleReader (h :: Effects -> Type) (e :: Effects)
runHandleReader :: forall (e1 :: Effects) (es :: Effects) h r. (e1 <: es, Handle h) => h e1 -> (forall (e :: Effects). () => HandleReader h e -> Eff (e :& es) r) -> Eff es r
askHandle :: forall (e :: Effects) (es :: Effects) h. (e <: es, Handle h) => HandleReader h e -> Eff es (h es)
asksHandle :: forall (e1 :: Effects) (es :: Effects) h r. (e1 <: es, Handle h) => HandleReader h e1 -> (forall (e :: Effects). () => h e -> Eff (e :& es) r) -> Eff es r
localHandle :: forall (e :: Effects) (es :: Effects) h r. (e <: es, Handle h) => HandleReader h e -> (h es -> h es) -> Eff es r -> Eff es r

module Bluefin.IO
data () => IOE (e :: Effects)
runEff :: (forall (e :: Effects). () => IOE e -> Eff e a) -> IO a
effIO :: forall (e :: Effects) (es :: Effects) a. e <: es => IOE e -> IO a -> Eff es a
rethrowIO :: forall ex (es :: Effects) (e1 :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es, Exception ex) => IOE e1 -> Exception ex e2 -> Eff es r -> Eff es r
withMonadIO :: forall (e :: Effects) (es :: Effects) r. e <: es => IOE e -> (forall (m :: Type -> Type). MonadIO m => m r) -> Eff es r
withEffToIO_ :: forall (e :: Effects) (es :: Effects) a. e <: es => IOE e -> ((forall r. () => Eff es r -> IO r) -> IO a) -> Eff es a
withEffToIOCloneHandle :: forall (e1 :: Effects) (es :: Effects) h a. (e1 <: es, CloneableHandle h) => IOE e1 -> h es -> ((forall r. () => (forall (e :: Effects). () => IOE e -> h e -> Eff e r) -> IO r) -> IO a) -> Eff es a
data () => EffReader r (es :: Effects) a
effReader :: forall r (es :: Effects) a. (r -> Eff es a) -> EffReader r es a
runEffReader :: forall r (es :: Effects) a. r -> EffReader r es a -> Eff es a
withEffToIO :: forall (e2 :: Effects) (es :: Effects) a. e2 <: es => ((forall r. () => (forall (e1 :: Effects). () => IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> IOE e2 -> Eff es a
runEff_ :: (forall (e :: Effects). () => IOE e -> Eff e a) -> IO a


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.JumpTo</a> instead.
module Bluefin.Jump
type Jump = EarlyReturn ()
withJump :: forall (es :: Effects). (forall (e :: Effects). () => Jump e -> Eff (e :& es) ()) -> Eff es ()
jumpTo :: forall (e :: Effects) (es :: Effects) a. e <: es => Jump e -> Eff es a


-- | Reimplementation of the <tt>pipes</tt> (<tt>Pipes</tt>) ecosystem in
--   Bluefin.
--   
--   You should not use this module. It will be deprecated and removed in
--   future versions.
--   
--   This module is just an example of what you can do with Bluefin and as
--   such it should be obtained from <a><tt>bluefin-examples</tt></a> if
--   you want it. Instead of using it directly you are recommended to use
--   
--   <ul>
--   <li><a>Yield</a>, <a>yield</a></li>
--   <li><a>Await</a>, <a>await</a></li>
--   <li><a>awaitYield</a></li>
--   <li>For advanced cases only, <a>Request</a>, <a>request</a> and
--   <a>connectRequests</a></li>
--   </ul>
--   
--   See also <a>Bluefin.Pipes.Prelude</a>.
module Bluefin.Pipes
data () => Proxy a' a b' b (e :: Effects)
type Effect = Producer Void
runEffect :: forall (es :: Effects) r. (forall (e :: Effects). () => Effect e -> Eff (e :& es) r) -> Eff es r
type Producer = Proxy Void () ()
yield :: forall (e :: Effects) (es :: Effects) x1 x a. e <: es => Proxy x1 x () a e -> a -> Eff es ()
for :: forall (e1 :: Effects) (es :: Effects) x' x b' b a' c' c. e1 <: es => (forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> Proxy x' x c' c e1 -> Eff es a'
(~>) :: forall (e1 :: Effects) (es :: Effects) a x' x b' b a' c' c. e1 <: es => (a -> forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> a -> Proxy x' x c' c e1 -> Eff es a'
(<~) :: forall (e1 :: Effects) (es :: Effects) b x' x c' c b' a a'. e1 <: es => (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> (a -> forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> a -> Proxy x' x c' c e1 -> Eff es a'
type Consumer a = Pipe a Void
await :: forall (e :: Effects) (es :: Effects) a y' y. e <: es => Proxy () a y' y e -> Eff es a
(>~) :: forall (e1 :: Effects) (es :: Effects) a' a y' y b c. e1 <: es => (forall (e :: Effects). () => Proxy a' a y' y e -> Eff (e :& es) b) -> (forall (e :: Effects). () => Proxy () b y' y e -> Eff (e :& es) c) -> Proxy a' a y' y e1 -> Eff es c
(~<) :: forall (e1 :: Effects) (es :: Effects) b y' y c a' a. e1 <: es => (forall (e :: Effects). () => Proxy () b y' y e -> Eff (e :& es) c) -> (forall (e :: Effects). () => Proxy a' a y' y e -> Eff (e :& es) b) -> Proxy a' a y' y e1 -> Eff es c
type Pipe a = Proxy () a ()
cat :: forall a (e :: Effects) (es :: Effects) r. Pipe a a e -> Eff (e :& es) r
(>->) :: forall (e1 :: Effects) (es :: Effects) a' a b r c' c. e1 <: es => (forall (e :: Effects). () => Proxy a' a () b e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Proxy () b c' c e -> Eff (e :& es) r) -> Proxy a' a c' c e1 -> Eff es r
(<-<) :: forall (e1 :: Effects) (es :: Effects) b c' c r a' a. e1 <: es => (forall (e :: Effects). () => Proxy () b c' c e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Proxy a' a () b e -> Eff (e :& es) r) -> Proxy a' a c' c e1 -> Eff es r
next :: ()
each :: forall f a x' x (e :: Effects) (es :: Effects). Foldable f => f a -> Proxy x' x () a e -> Eff (e :& es) ()


-- | Reimplementation of the <tt>pipes</tt> (<tt>Pipes</tt>) ecosystem in
--   Bluefin.
--   
--   You should not use this module. It will be deprecated and removed in
--   future versions.
--   
--   This module is just an example of what you can do with Bluefin and as
--   such it should be obtained from <a><tt>bluefin-examples</tt></a> if
--   you want it. Instead of using it directly you are recommended to use
--   
--   <ul>
--   <li><a>Yield</a>, <a>yield</a></li>
--   <li><a>Await</a>, <a>await</a></li>
--   <li><a>awaitYield</a></li>
--   <li>For advanced cases only, <a>Request</a>, <a>request</a> and
--   <a>connectRequests</a></li>
--   </ul>
--   
--   See also <a>Bluefin.Pipes</a>.
--   
--   <pre>
--   &gt;&gt;&gt; <a>runEff</a> $ \io -&gt; <a>runEffect</a> $ do
--         <a>stdinLn</a> io &gt;-&gt; <a>takeWhile'</a> (/= "quit") &gt;-&gt; <a>stdoutLn</a> io
--   Test
--   Test
--   ABC
--   ABC
--   quit
--   "quit"
--   </pre>
module Bluefin.Pipes.Prelude
stdinLn :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es) => IOE e1 -> Producer String e2 -> Eff es r
repeatM :: forall (e :: Effects) (es :: Effects) a x' x r. e <: es => Eff es a -> Proxy x' x () a e -> Eff es r
replicateM :: forall (e :: Effects) (es :: Effects) a x' x. e <: es => Int -> Eff es a -> Proxy x' x () a e -> Eff es ()
unfoldr :: forall (e :: Effects) (es :: Effects) s r a x1 x. e <: es => (s -> Eff es (Either r (a, s))) -> s -> Proxy x1 x () a e -> Eff es r
stdoutLn :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es) => IOE e1 -> Consumer String e2 -> Eff es r
mapM_ :: forall (e :: Effects) (es :: Effects) a b b' r. e <: es => (a -> Eff es ()) -> Proxy () a b b' e -> Eff es r
print :: forall (e2 :: Effects) (es :: Effects) (e1 :: Effects) a r. (e2 <: es, e1 <: es, Show a) => IOE e1 -> Consumer a e2 -> Eff es r
drain :: forall (e :: Effects) (es :: Effects) b c' c r. e <: es => Proxy () b c' c e -> Eff es r
map :: forall (e :: Effects) (es :: Effects) a b r. e <: es => (a -> b) -> Pipe a b e -> Eff es r
mapM :: forall (e :: Effects) (es :: Effects) a b r. e <: es => (a -> Eff es b) -> Pipe a b e -> Eff es r
takeWhile' :: forall (e :: Effects) (es :: Effects) r. e <: es => (r -> Bool) -> Pipe r r e -> Eff es r


-- | For defining <tt>PrimMonad</tt> instances, for example:
--   
--   <pre>
--   -- Define a capability which includes Prim
--   data ExAndPrim e = MkExAndPrim (Exception String e) (P.Prim e)
--     -- Give it a Handle instance, as per Bluefin.Compound
--     deriving (Handle) via OneWayCoercibleHandle ExAndPrim
--     deriving stock (Generic)
--   
--   instance (e &lt;: es) =&gt; OneWayCoercible (ExAndPrim e) (ExAndPrim es) where
--     oneWayCoercibleImpl = gOneWayCoercible
--   
--   -- Define a monad M containing the Prim capability
--   newtype M e es a = MkM (ReaderT (ExAndPrim e) (Eff es) a)
--     deriving newtype (Functor, Applicative, Monad)
--   
--   -- Define a way of running M
--   runM ::
--     (e1 &lt;: es, e2 &lt;: es) =&gt;
--     Exception String e1 -&gt;
--     P.Prim e2 -&gt;
--     M es es r -&gt;
--     Eff es r
--   runM ex prim (MkM m) =
--     runReaderT m (MkExAndPrim (mapHandle ex) (mapHandle prim))
--   
--   -- Give M a PrimMonad instance
--   instance (e &lt;: es) =&gt; PrimMonad (M e es) where
--     type PrimState (M e es) = P.PrimStateEff e
--     primitive f =
--       MkM (ReaderT (\(MkExAndPrim _ prim) -&gt; P.<a>primitive</a> prim f))
--   
--   -- ghci&gt; example
--   -- Right ["Hello","World"]
--   example :: Either String [String]
--   example = runPureEff $ try $ \ex -&gt; P.<a>runPrim</a> $ \prim -&gt; do
--     runM ex prim $ do
--       arr &lt;- A.newArray 2 "Hello"
--       A.writeArray arr 1 "World"
--       for [0, 1] (A.readArray arr)
--   </pre>
module Bluefin.Prim
data () => Prim (e :: Effects)
runPrim :: forall (es :: Effects) r. (forall (e :: Effects). () => Prim e -> Eff (e :& es) r) -> Eff es r
data () => PrimStateEff (es :: Effects)
primitive :: forall (e1 :: Effects) (es :: Effects) a. e1 <: es => Prim e1 -> (State# (PrimStateEff e1) -> (# State# (PrimStateEff e1), a #)) -> Eff es a


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Ask</a> instead.
module Bluefin.Reader
data () => Reader r (e :: Effects)
runReader :: forall r (es :: Effects) a. r -> (forall (e :: Effects). () => Reader r e -> Eff (e :& es) a) -> Eff es a
ask :: forall (e :: Effects) (es :: Effects) r. e <: es => Reader r e -> Eff es r
asks :: forall (e :: Effects) (es :: Effects) r a. e <: es => Reader r e -> (r -> a) -> Eff es a
local :: forall (e1 :: Effects) (es :: Effects) r a. e1 <: es => Reader r e1 -> (r -> r) -> Eff es a -> Eff es a


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Modify</a> instead.
module Bluefin.State
data () => State s (e :: Effects)
evalState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) a) -> Eff es a
runState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) a) -> Eff es (a, s)
withState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) (s -> a)) -> Eff es a
get :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> Eff es s
put :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> s -> Eff es ()
modify :: forall (e :: Effects) (es :: Effects) s. e <: es => State s e -> (s -> s) -> Eff es ()

module Bluefin.StateSource
data () => StateSource (e :: Effects)
withStateSource :: forall (es :: Effects) a. (forall (e :: Effects). () => StateSource e -> Eff (e :& es) a) -> Eff es a
newState :: forall (e :: Effects) (es :: Effects) s. e <: es => StateSource e -> s -> Eff es (State s e)


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Yield</a> instead.
module Bluefin.Stream
type Stream a = Coroutine a ()
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
yieldToList :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)
yieldToReverseList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> Eff es ([a], r)
withYieldToList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) ([a] -> r)) -> Eff es r
ignoreStream :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es r
enumerate :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r
enumerateFrom :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => Int -> (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r
mapMaybe :: forall (e2 :: Effects) (es :: Effects) a b r. e2 <: es => (a -> Maybe b) -> (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Stream b e2 -> Eff es r
catMaybes :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Stream (Maybe a) e1 -> Eff (e1 :& es) r) -> Stream a e2 -> Eff es r
consumeStream :: forall a (es :: Effects) r. (forall (e :: Effects). () => Consume a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> Eff es r
streamConsume :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Consume a e -> Eff (e :& es) r) -> Eff es r
yield :: forall (e1 :: Effects) (es :: Effects) a. e1 <: es => Stream a e1 -> a -> Eff es ()
inFoldable :: forall t (e1 :: Effects) (es :: Effects) a. (Foldable t, e1 <: es) => t a -> Stream a e1 -> Eff es ()
cycleToStream :: forall f (e1 :: Effects) (es :: Effects) a. (Foldable f, e1 <: es) => f a -> Stream a e1 -> Eff es ()
takeConsume :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) a. (e1 <: es, e2 <: es) => Int -> Consume a e1 -> Stream a e2 -> Eff es ()


-- | A safer interface to <tt>System.IO.<a>Handle</a></tt>
module Bluefin.System.IO
data () => Handle (e :: Effects)
withFile :: forall (e1 :: Effects) (es :: Effects) r. e1 <: es => IOE e1 -> FilePath -> IOMode -> (forall (e :: Effects). () => Handle e -> Eff (e :& es) r) -> Eff es r
hPutChar :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> Char -> Eff es ()
hPutStr :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> String -> Eff es ()
hPutStrLn :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> String -> Eff es ()
hGetLine :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> Eff es String
hIsEOF :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> Eff es Bool
hFlush :: forall (e :: Effects) (es :: Effects). e <: es => Handle e -> Eff es ()
unsafeWithHandle :: forall (e1 :: Effects) (es :: Effects) r. e1 <: es => Handle e1 -> (Handle -> IO r) -> Eff es r


-- | This is an old interface and will be deprecated in the future. You are
--   encouraged to use <a>Bluefin.Capability.Writer</a> instead.
module Bluefin.Writer
data () => Writer w (e :: Effects)
runWriter :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Writer w e -> Eff (e :& es) r) -> Eff es (r, w)
execWriter :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Writer w e -> Eff (e :& es) r) -> Eff es w
tell :: forall (e :: Effects) (es :: Effects) w. e <: es => Writer w e -> w -> Eff es ()
