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


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

module Bluefin

module Bluefin.Capability

module Bluefin.Capability.Ask
data () => Ask r (e :: Effects)
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 => Ask r e -> Eff es r
asks :: forall (e :: Effects) (es :: Effects) r a. e <: es => Ask r e -> (r -> a) -> Eff es a
local :: forall (e1 :: Effects) (es :: Effects) r a. e1 <: es => Ask 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
data () => AskCapability (h :: Effects -> Type) (e :: Effects)
runAskCapability :: forall (e1 :: Effects) (es :: Effects) h r. (e1 <: es, Handle h) => h e1 -> (forall (e :: Effects). () => AskCapability h e -> Eff (e :& es) r) -> Eff es r
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
askCapability :: forall (e :: Effects) (es :: Effects) h. (e <: es, Handle h) => AskCapability h e -> Eff es (h es)

module Bluefin.Capability.Await
type Await a = Request () 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 => Await 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 = ReturnEarly ()
withJumpTo :: forall (es :: Effects). (forall (e :: Effects). () => JumpTo e -> Eff (e :& es) ()) -> Eff es ()
jumpTo :: forall (e :: Effects) (es :: Effects) a. e <: es => JumpTo e -> Eff es a

module Bluefin.Capability.Modify
data () => Modify s (e :: Effects)
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 => Modify s e -> Eff es s
put :: forall (e :: Effects) (es :: Effects) s. e <: es => Modify s e -> s -> Eff es ()
modify :: forall (e :: Effects) (es :: Effects) s. e <: es => Modify s e -> (s -> s) -> Eff es ()

module Bluefin.Capability.Request
data () => Request a b (e :: Effects)
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Request 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 = Throw
withReturnEarly :: forall r (es :: Effects). (forall (e :: Effects). () => ReturnEarly r e -> Eff (e :& es) r) -> Eff es r
returnEarly :: forall (e :: Effects) (es :: Effects) r a. e <: es => ReturnEarly r e -> r -> Eff es a

module Bluefin.Capability.Tell
data () => Tell w (e :: Effects)
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 => Tell w e -> w -> Eff es ()

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

module Bluefin.Capability.Yield
type Yield a = Request a ()
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Request a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
yieldToList :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)
yieldToPureList :: (forall (e :: Effects). () => Yield a e -> Eff e r) -> ([a], r)
yieldToReverseList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Yield a e -> Eff (e :& es) r) -> Eff es ([a], r)
withYieldToList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Yield a e -> Eff (e :& es) ([a] -> r)) -> Eff es r
ignoreYield :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Eff es r
enumerate :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield (Int, a) e2 -> Eff es r
enumerateFrom :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => Int -> (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield (Int, a) e2 -> Eff es r
mapMaybe :: forall (e2 :: Effects) (es :: Effects) a b r. e2 <: es => (a -> Maybe b) -> (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield b e2 -> Eff es r
catMaybes :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Yield (Maybe a) e1 -> Eff (e1 :& es) r) -> Yield 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 => Yield a e1 -> a -> Eff es ()
inFoldable :: forall t (e1 :: Effects) (es :: Effects) a. (Foldable t, e1 <: es) => t a -> Yield 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 forall (e :: Effects) (es :: Effects). e <: es => OneWayCoercible h e h es => 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
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)
oneWayCoercibleNewtypeHandle :: forall {k} (h1 :: Effects -> k) (h2 :: Effects -> k) (e :: Effects) (es :: Effects). (e :> es, Coercible (h2 e) (h1 e), OneWayCoercible (h1 e) (h1 es), Coercible (h1 es) (h2 es)) => OneWayCoercibleD (h2 e) (h2 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
withHandle :: Handle h => ((forall (e :: Effects) (es :: Effects). e <: es => OneWayCoercible (h e) (h es)) => r) -> 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 = Await 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 => Await 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
type Coroutine = Request
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Request 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 r = ReturnEarly r
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 => ReturnEarly 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 => Throw 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
type Exception = Throw
try :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Throw exn e -> Eff (e :& es) a) -> Eff es (Either exn a)
handle :: forall exn (es :: Effects) a. (exn -> Eff es a) -> (forall (e :: Effects). () => Throw exn e -> Eff (e :& es) a) -> Eff es a
catch :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Throw exn e -> Eff (e :& es) a) -> (exn -> Eff es a) -> Eff es a
throw :: forall (e :: Effects) (es :: Effects) ex a. e <: es => Throw ex e -> ex -> Eff es a
rethrowIO :: forall ex (es :: Effects) (e1 :: Effects) (e2 :: Effects) r. (e1 <: es, e2 <: es, Exception ex) => IOE e1 -> Throw 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 (Throw 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) -> AskCapability (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
type HandleReader = AskCapability
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
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
askHandle :: forall (e :: Effects) (es :: Effects) h. (e <: es, Handle h) => HandleReader h e -> Eff es (h es)

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 -> Throw 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 = JumpTo
withJump :: forall (es :: Effects). (forall (e :: Effects). () => Jump e -> Eff (e :& es) ()) -> Eff es ()
jumpTo :: forall (e :: Effects) (es :: Effects) a. e <: es => JumpTo e -> Eff es a


-- | For defining <tt>PrimMonad</tt> instances, for example:
--   
--   <pre>
--   -- Define a capability which includes Prim
--   data ExAndPrim e1 e2 = MkExAndPrim (Throw String e2) (P.Prim e1 e2)
--     -- Give it a Handle instance, as per Bluefin.Compound
--     deriving (Handle) via OneWayCoercibleHandle (ExAndPrim e1)
--     deriving stock (Generic)
--   
--   instance (e2 &lt;: es) =&gt; OneWayCoercible (ExAndPrim e1 e2) (ExAndPrim e1 es) where
--     oneWayCoercibleImpl = gOneWayCoercible
--   
--   -- Define a monad M containing the Prim capability
--   newtype M e a = MkM (DslBuilder (ExAndPrim e) a)
--     deriving newtype (Functor, Applicative, Monad)
--   
--   -- Define a way of running M
--   runM ::
--     (e1 &lt;: es, e2 &lt;: es) =&gt;
--     Throw String e1 -&gt;
--     P.Prim e e2 -&gt;
--     M e r -&gt;
--     Eff es r
--   runM ex prim (MkM m) =
--     runDslBuilder (MkExAndPrim (mapHandle ex) (mapHandle prim)) m
--   
--   -- Give M a PrimMonad instance
--   instance PrimMonad (M e) where
--     type PrimState (M e) = P.PrimStateEff e
--     primitive f =
--       MkM (dslBuilder (\(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 (e1 :: Effects) (e2 :: Effects)
runPrim :: forall (es :: Effects) r. (forall (e :: Effects). () => Prim e e -> Eff (e :& es) r) -> Eff es r
data () => PrimStateEff (es :: Effects)
primitive :: forall (e1 :: Effects) (e2 :: Effects) (es :: Effects) a. e2 <: es => Prim e1 e2 -> (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
type Reader = Ask
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 => Ask r e -> Eff es r
asks :: forall (e :: Effects) (es :: Effects) r a. e <: es => Ask r e -> (r -> a) -> Eff es a
local :: forall (e1 :: Effects) (es :: Effects) r a. e1 <: es => Ask 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
type State = Modify
evalState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => Modify s e -> Eff (e :& es) a) -> Eff es a
runState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => Modify s e -> Eff (e :& es) a) -> Eff es (a, s)
withState :: 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 => Modify s e -> Eff es s
put :: forall (e :: Effects) (es :: Effects) s. e <: es => Modify s e -> s -> Eff es ()
modify :: forall (e :: Effects) (es :: Effects) s. e <: es => Modify 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 (Modify 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 = Yield a
forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Request a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r
yieldToList :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)
yieldToReverseList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Yield a e -> Eff (e :& es) r) -> Eff es ([a], r)
withYieldToList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Yield 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). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield (Int, a) e2 -> Eff es r
enumerateFrom :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => Int -> (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield (Int, a) e2 -> Eff es r
mapMaybe :: forall (e2 :: Effects) (es :: Effects) a b r. e2 <: es => (a -> Maybe b) -> (forall (e1 :: Effects). () => Yield a e1 -> Eff (e1 :& es) r) -> Yield b e2 -> Eff es r
catMaybes :: forall (e2 :: Effects) (es :: Effects) a r. e2 <: es => (forall (e1 :: Effects). () => Yield (Maybe a) e1 -> Eff (e1 :& es) r) -> Yield 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 => Yield a e1 -> a -> Eff es ()
inFoldable :: forall t (e1 :: Effects) (es :: Effects) a. (Foldable t, e1 <: es) => t a -> Yield a e1 -> Eff es ()
cycleToStream :: forall f (e1 :: Effects) (es :: Effects) a. (Foldable f, e1 <: es) => f a -> Yield 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
type Writer = Tell
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 => Tell w e -> w -> Eff es ()
