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


-- | A basic framework for effect systems based on effects represented by GADTs.
--   
--   A basic framework for a Haskell effect system library based on
--   GADTs-based effect representations with a style that separates
--   first-order effects and higher-order effects.
--   
--   This library set was created by being separated from the <a>Heftia</a>
--   extensible effects library.
@package data-effects
@version 0.3.0.0


-- | Effects that can accumulate values monoidally in a context.
module Data.Effect.Writer

-- | An effect that can accumulate values monoidally in a context.
data Tell w a

-- | Accumulates new values to the cumulative value held in the context.
[Tell] :: forall w. w -> Tell w ()

-- | An effect that performs local operations on accumulations in the
--   context on a per-scope basis.
data WriterH w (f :: Type -> Type) a

-- | Obtains the accumulated value in the scope and returns it together as
--   a pair.
[Listen] :: forall (f :: Type -> Type) a1 w. f a1 -> WriterH w f (w, a1)

-- | Modifies the accumulation in the scope based on the given function.
[Censor] :: forall w (f :: Type -> Type) a. (w -> w) -> f a -> WriterH w f a
type LTell w = LiftFOE Tell w
pattern LTell :: forall a w f. () => (a ~ (), ()) => w -> LiftFOE (Tell w) f a

-- | Accumulates new values to the cumulative value held in the context.
tell :: SendFOE (Tell w) f => w -> f ()

-- | Accumulates new values to the cumulative value held in the context.
tell' :: forall {k} (tag :: k) w f. SendFOE (Tag (Tell w) tag) f => w -> f ()

-- | Accumulates new values to the cumulative value held in the context.
tell'' :: forall {k} (key :: k) w f. SendFOEBy key (Tell w) f => w -> f ()

-- | Obtains the accumulated value in the scope and returns it together as
--   a pair.
listen :: forall a w f. SendHOE (WriterH w) f => f a -> f (w, a)

-- | Obtains the accumulated value in the scope and returns it together as
--   a pair.
listen' :: forall {k} (tag :: k) a w f. SendHOE (TagH (WriterH w) tag) f => f a -> f (w, a)

-- | Obtains the accumulated value in the scope and returns it together as
--   a pair.
listen'' :: forall {k} (key :: k) a w f. SendHOEBy key (WriterH w) f => f a -> f (w, a)

-- | Modifies the accumulation in the scope based on the given function.
censor :: forall w a f. SendHOE (WriterH w) f => (w -> w) -> f a -> f a

-- | Modifies the accumulation in the scope based on the given function.
censor' :: forall {k} (tag :: k) w a f. SendHOE (TagH (WriterH w) tag) f => (w -> w) -> f a -> f a

-- | Modifies the accumulation in the scope based on the given function.
censor'' :: forall {k} (key :: k) w a f. SendHOEBy key (WriterH w) f => (w -> w) -> f a -> f a

-- | For a given scope, uses the function (the first component of the pair
--   returned by that scope) to modify the accumulated value of that scope,
--   and then accumulates the result into the current outer scope.
--   
--   <pre>
--   pass m = do
--       (w, (f, a)) &lt;- listen m
--       tell $ f w
--       pure a
--   </pre>
pass :: (Tell w <: m, WriterH w <<: m, Monad m) => m (w -> w, a) -> m a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Writer.WriterH w)


-- | Realizes <a><tt>unliftio</tt></a> in the form of higher-order effects.
module Data.Effect.Unlift
data UnliftBase (b :: Type -> Type) (f :: Type -> Type) a
[WithRunInBase] :: forall (f :: Type -> Type) (b :: Type -> Type) a. ((forall x. () => f x -> b x) -> b a) -> UnliftBase b f a
withRunInBase :: forall b a f. SendHOE (UnliftBase b) f => ((forall x. () => f x -> b x) -> b a) -> f a
withRunInBase' :: forall {k} (tag :: k) b a f. SendHOE (TagH (UnliftBase b) tag) f => ((forall x. () => f x -> b x) -> b a) -> f a
withRunInBase'' :: forall {k} (key :: k) b a f. SendHOEBy key (UnliftBase b) f => ((forall x. () => f x -> b x) -> b a) -> f a
type UnliftIO = UnliftBase IO
pattern WithRunInIO :: ((f ~> IO) -> IO a) -> UnliftIO f a
withRunInIO :: UnliftIO <<: f => ((f ~> IO) -> IO a) -> f a
withRunInIO' :: forall {k} (tag :: k) f a. (UnliftIO ## tag) <<: f => ((f ~> IO) -> IO a) -> f a
withRunInIO'' :: forall {k} (key :: k) f a. SendHOEBy key UnliftIO f => ((f ~> IO) -> IO a) -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Unlift.UnliftBase b)


-- | Effects for holding mutable state values in the context.
module Data.Effect.State

-- | An effect for holding mutable state values in the context.
data State s a

-- | Retrieves the current state value from the context.
[Get] :: forall s. State s s

-- | Overwrites the state value in the context.
[Put] :: forall s. s -> State s ()
type LState s = LiftFOE State s
pattern LPut :: forall a s f. () => (a ~ (), ()) => s -> LiftFOE (State s) f a
pattern LGet :: forall a s f. () => (a ~ s, ()) => LiftFOE (State s) f a

-- | Retrieves the current state value from the context.
get :: SendFOE (State s) f => f s

-- | Retrieves the current state value from the context.
get' :: forall {k} (tag :: k) s f. SendFOE (Tag (State s) tag) f => f s

-- | Retrieves the current state value from the context.
get'' :: forall {k} (key :: k) s f. SendFOEBy key (State s) f => f s

-- | Overwrites the state value in the context.
put :: SendFOE (State s) f => s -> f ()

-- | Overwrites the state value in the context.
put' :: forall {k} (tag :: k) s f. SendFOE (Tag (State s) tag) f => s -> f ()

-- | Overwrites the state value in the context.
put'' :: forall {k} (key :: k) s f. SendFOEBy key (State s) f => s -> f ()

-- | Retrieves the current state value from the context and returns the
--   value transformed based on the given function.
gets :: (State s <: f, Functor f) => (s -> a) -> f a

-- | Modifies the current state value in the context based on the given
--   function.
modify :: (State s <: m, Monad m) => (s -> s) -> m ()

module Data.Effect.ShiftReset
data Shift' ans (n :: Type -> Type) (m :: Type -> Type) a
[Shift] :: forall ans (n :: Type -> Type) (m :: Type -> Type) a. ((a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> Shift' ans n m a
type Shift ans (n :: Type -> Type) = ShiftKey ##> Shift' ans n
data ShiftKey
shift'_ :: forall ans n a m. SendHOE (Shift' ans n) m => ((a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift' :: forall {k} (tag :: k) ans n a m. SendHOE (TagH (Shift' ans n) tag) m => ((a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift'' :: forall {k} (key :: k) ans n a m. SendHOEBy key (Shift' ans n) m => ((a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift :: forall ans n a m. SendHOEBy ShiftKey (Shift' ans n) m => ((a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
callCC :: forall a m ans n. (SendHOEBy ShiftKey (Shift' ans n) m, Monad m, Monad n) => ((a -> n ans) -> m a) -> m a
exit :: forall a m ans (n :: Type -> Type). (SendHOEBy ShiftKey (Shift' ans n) m, Applicative n) => ans -> m a
getCC :: forall m ans n. (SendHOEBy ShiftKey (Shift' ans n) m, Monad m, Monad n) => m (n ans)
embed :: forall (m :: Type -> Type) ans (n :: Type -> Type). (SendHOEBy ShiftKey (Shift' ans n) m, Monad n) => n ~> m
data Shift_' (n :: Type -> Type) (m :: Type -> Type) a
[Shift_'] :: forall a (n :: Type -> Type) (m :: Type -> Type). (forall ans. () => (a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> Shift_' n m a
type Shift_ (n :: Type -> Type) = Shift_Key ##> Shift_' n
data Shift_Key
shift_''_ :: forall a n m. SendHOE (Shift_' n) m => (forall ans. () => (a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift_'' :: forall {k} (tag :: k) a n m. SendHOE (TagH (Shift_' n) tag) m => (forall ans. () => (a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift_''' :: forall {k} (key :: k) a n m. SendHOEBy key (Shift_' n) m => (forall ans. () => (a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
shift_' :: forall a n m. SendHOEBy Shift_Key (Shift_' n) m => (forall ans. () => (a -> n ans) -> (forall x. () => m x -> n x) -> n ans) -> m a
getCC_ :: forall m n. (SendHOEBy Shift_Key (Shift_' n) m, Functor n) => m (n ())
data Reset (m :: Type -> Type) a
[Reset] :: forall (m :: Type -> Type) a. m a -> Reset m a
reset :: forall a m. SendHOE Reset m => m a -> m a
reset' :: forall {k} (tag :: k) a m. SendHOE (TagH Reset tag) m => m a -> m a
reset'' :: forall {k} (key :: k) a m. SendHOEBy key Reset m => m a -> m a
data ShiftF ans a
[ShiftF] :: forall ans a. ((a -> ans) -> ans) -> ShiftF ans a
type LShiftF ans = LiftFOE ShiftF ans
pattern LShiftF :: forall a ans f a1. () => (a ~ a1, ()) => ((a1 -> ans) -> ans) -> LiftFOE (ShiftF ans) f a
shiftF :: forall ans a f. SendFOE (ShiftF ans) f => ((a -> ans) -> ans) -> f a
shiftF' :: forall {k} (tag :: k) ans a f. SendFOE (Tag (ShiftF ans) tag) f => ((a -> ans) -> ans) -> f a
shiftF'' :: forall {k} (key :: k) ans a f. SendFOEBy key (ShiftF ans) f => ((a -> ans) -> ans) -> f a
fromShiftF :: forall n ans (m :: Type -> Type) x. ShiftF (n ans) x -> Shift ans n m x
exitF :: ShiftF ans <: m => ans -> m a
embedF :: forall ans (n :: Type -> Type) (m :: Type -> Type). (ShiftF (n ans) <: m, Monad n) => n ~> m
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.ShiftReset.Reset
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.ShiftReset.Shift' ans n)
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.ShiftReset.Shift_' n)

module Data.Effect.Select
data Select r a
[Select] :: forall a r. ((a -> r) -> a) -> Select r a
type LSelect r = LiftFOE Select r
pattern LSelect :: forall a r f a1. () => (a ~ a1, ()) => ((a1 -> r) -> a1) -> LiftFOE (Select r) f a
select :: forall a r f. SendFOE (Select r) f => ((a -> r) -> a) -> f a
select' :: forall {k} (tag :: k) a r f. SendFOE (Tag (Select r) tag) f => ((a -> r) -> a) -> f a
select'' :: forall {k} (key :: k) a r f. SendFOEBy key (Select r) f => ((a -> r) -> a) -> f a


-- | An effect capable of providing <a>bracket</a> semantics.
module Data.Effect.Resource

-- | An effect capable of providing <a>bracket</a> semantics.
data Resource (f :: Type -> Type) a

-- | Allocate a resource, use it, and clean it up afterwards.
[Bracket] :: forall (f :: Type -> Type) a1 a. f a1 -> (a1 -> f ()) -> (a1 -> f a) -> Resource f a

-- | Allocate a resource, use it, and clean it up afterwards if an error
--   occurred.
[BracketOnExcept] :: forall (f :: Type -> Type) a1 a. f a1 -> (a1 -> f ()) -> (a1 -> f a) -> Resource f a

-- | Allocate a resource, use it, and clean it up afterwards.
bracket :: forall a b f. SendHOE Resource f => f a -> (a -> f ()) -> (a -> f b) -> f b

-- | Allocate a resource, use it, and clean it up afterwards.
bracket' :: forall {k} (tag :: k) a b f. SendHOE (TagH Resource tag) f => f a -> (a -> f ()) -> (a -> f b) -> f b

-- | Allocate a resource, use it, and clean it up afterwards.
bracket'' :: forall {k} (key :: k) a b f. SendHOEBy key Resource f => f a -> (a -> f ()) -> (a -> f b) -> f b

-- | Allocate a resource, use it, and clean it up afterwards if an error
--   occurred.
bracketOnExcept :: forall a b f. SendHOE Resource f => f a -> (a -> f ()) -> (a -> f b) -> f b

-- | Allocate a resource, use it, and clean it up afterwards if an error
--   occurred.
bracketOnExcept' :: forall {k} (tag :: k) a b f. SendHOE (TagH Resource tag) f => f a -> (a -> f ()) -> (a -> f b) -> f b

-- | Allocate a resource, use it, and clean it up afterwards if an error
--   occurred.
bracketOnExcept'' :: forall {k} (key :: k) a b f. SendHOEBy key Resource f => f a -> (a -> f ()) -> (a -> f b) -> f b
bracket_ :: (Resource <<: f, Functor f) => f a -> f b -> f c -> f c
bracketOnExcept_ :: (Resource <<: f, Functor f) => f a -> f b -> f c -> f c
finally :: (Resource <<: f, Applicative f) => f a -> f () -> f a
finally_ :: (Resource <<: f, Applicative f) => f a -> f b -> f a
onException :: (Resource <<: f, Applicative f) => f a -> f () -> f a
onException_ :: (Resource <<: f, Applicative f) => f a -> f b -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.Resource.Resource


-- | Effects that can be used to hold environmental values in the context.
--   Environmental values are immutable and do not change across
--   procedures, but you can modify the value within a local scope using
--   the <a>local</a> operation.
module Data.Effect.Reader

-- | An effect that holds a value of type <tt>r</tt> in the context
--   (environment).
data Ask r a

-- | Obtain a value from the environment.
[Ask] :: forall r. Ask r r

-- | An effect that locally modifies the value held in the environment.
data Local r (f :: Type -> Type) a

-- | Locally modifies the value held in the environment.
[Local] :: forall r (f :: Type -> Type) a. (r -> r) -> f a -> Local r f a
type LAsk r = LiftFOE Ask r
pattern LAsk :: forall a r f. () => (a ~ r, ()) => LiftFOE (Ask r) f a

-- | Obtain a value from the environment.
ask :: SendFOE (Ask r) f => f r

-- | Obtain a value from the environment.
ask' :: forall {k} (tag :: k) r f. SendFOE (Tag (Ask r) tag) f => f r

-- | Obtain a value from the environment.
ask'' :: forall {k} (key :: k) r f. SendFOEBy key (Ask r) f => f r

-- | Locally modifies the value held in the environment.
local :: forall r a f. SendHOE (Local r) f => (r -> r) -> f a -> f a

-- | Locally modifies the value held in the environment.
local' :: forall {k} (tag :: k) r a f. SendHOE (TagH (Local r) tag) f => (r -> r) -> f a -> f a

-- | Locally modifies the value held in the environment.
local'' :: forall {k} (key :: k) r a f. SendHOEBy key (Local r) f => (r -> r) -> f a -> f a

-- | Obtains a value from the environment and returns it transformed by the
--   given function.
asks :: (Ask r <: f, Functor f) => (r -> a) -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Reader.Local r)


-- | This module provides the <a>Provider</a> effect, like
--   <a><tt>Effectful.Provider</tt></a> in the <tt>effectful</tt> package.
module Data.Effect.Provider

-- | An effect to introduce a new local scope that provides effect context
--   <tt>b</tt>.
data Provider' (ctx :: k -> Type -> Type) (i :: k -> Type) (b :: k -> Type -> Type) (f :: Type -> Type) a

-- | Introduces a new local scope that provides an effect context <tt>b
--   p</tt> parameterized by type <tt>i p</tt> and with results wrapped in
--   <tt>ctx p</tt>.
[Provide] :: forall {k} (i :: k -> Type) (p :: k) (f :: Type -> Type) (b :: k -> Type -> Type) a1 (ctx :: k -> Type -> Type). i p -> ((forall x. () => f x -> b p x) -> b p a1) -> Provider' ctx i b f (ctx p a1)

-- | Introduces a new local scope that provides an effect context <tt>b
--   p</tt> parameterized by type <tt>i p</tt> and with results wrapped in
--   <tt>ctx p</tt>.
provide :: forall {k} i (p :: k) b a ctx f. SendHOE (Provider' ctx i b) f => i p -> ((forall x. () => f x -> b p x) -> b p a) -> f (ctx p a)

-- | Introduces a new local scope that provides an effect context <tt>b
--   p</tt> parameterized by type <tt>i p</tt> and with results wrapped in
--   <tt>ctx p</tt>.
provide' :: forall {k1} (tag :: k1) {k2} i (p :: k2) b a ctx f. SendHOE (TagH (Provider' ctx i b) tag) f => i p -> ((forall x. () => f x -> b p x) -> b p a) -> f (ctx p a)

-- | Introduces a new local scope that provides an effect context <tt>b
--   p</tt> parameterized by type <tt>i p</tt> and with results wrapped in
--   <tt>ctx p</tt>.
provide'' :: forall {k1} (key :: k1) {k2} i (p :: k2) b a ctx f. SendHOEBy key (Provider' ctx i b) f => i p -> ((forall x. () => f x -> b p x) -> b p a) -> f (ctx p a)

-- | A type-level key to uniquely resolve the effect context carrier
--   <tt>b</tt> from <tt>ctx</tt> and <tt>i</tt>.
data ProviderKey (ctx :: k) (i :: k1)

-- | An effect to introduce a new local scope that provides effect context
--   <tt>b</tt>.
type Provider (ctx :: k -> Type -> Type) (i :: k -> Type) (b :: k -> Type -> Type) = ProviderKey ctx i ##> Provider' ctx i b

-- | An effect to introduce a new local scope that provides effect context
--   <tt>b</tt>. A version of <a>Provider</a> where the result is not
--   wrapped in a specific container.
type Provider_ i (b :: Type -> Type) = Provider Const1 Identity :: () -> Type -> Type Const i :: () -> Type Const1 b :: () -> Type -> Type
newtype Const1 (f :: k -> Type) (x :: k1) (a :: k)
Const1 :: f a -> Const1 (f :: k -> Type) (x :: k1) (a :: k)
[getConst1] :: Const1 (f :: k -> Type) (x :: k1) (a :: k) -> f a
newtype Const2 (ff :: k -> k1 -> Type) (x :: k2) (f :: k) (a :: k1)
Const2 :: ff f a -> Const2 (ff :: k -> k1 -> Type) (x :: k2) (f :: k) (a :: k1)
[getConst2] :: Const2 (ff :: k -> k1 -> Type) (x :: k2) (f :: k) (a :: k1) -> ff f a

-- | A operator to introduce a new local scope that provides effect context
--   <tt>b</tt>. A version of <a>..!</a> where the result is not wrapped in
--   a specific container.
(.!) :: forall {k} i f a b. (SendHOEBy (ProviderKey (Const1 Identity :: () -> Type -> Type) (Const i :: () -> Type)) (Provider' (Const1 Identity :: k -> Type -> Type) (Const i :: k -> Type) (Const1 b :: k -> Type -> Type)) f, Functor f) => i -> ((f ~> b) -> b a) -> f a
infix 2 .!

-- | A operator to introduce a new local scope that provides effect context
--   <tt>b p</tt>.
(..!) :: forall {k} ctx i (p :: k) f a b. SendHOEBy (ProviderKey ctx i) (Provider' ctx i b) f => i p -> ((f ~> b p) -> b p a) -> f (ctx p a)
infix 2 ..!
instance forall k (ff :: (* -> *) -> * -> *) (x :: k). Data.Comp.Multi.HFunctor.HFunctor ff => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Provider.Const2 ff x)
instance forall k (ctx :: k -> * -> *) (i :: k -> *) (b :: k -> * -> *). (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Provider.Provider' ctx i b)


-- | This module provides the <a>Output</a> effect, comes from
--   <a><tt>Polysemy.Output</tt></a> in the <tt>polysemy</tt> package.
--   
--   Realizes output of values to the external world.
module Data.Effect.Output

-- | A general effect representing output of values to the external world.
data Output o a

-- | Output a value to the external world.
[Output] :: forall o. o -> Output o ()
type LOutput o = LiftFOE Output o
pattern LOutput :: forall a o f. () => (a ~ (), ()) => o -> LiftFOE (Output o) f a

-- | Output a value to the external world.
output :: SendFOE (Output o) f => o -> f ()

-- | Output a value to the external world.
output' :: forall {k} (tag :: k) o f. SendFOE (Tag (Output o) tag) f => o -> f ()

-- | Output a value to the external world.
output'' :: forall {k} (key :: k) o f. SendFOEBy key (Output o) f => o -> f ()


-- | Effects that realize non-deterministic computations.
module Data.Effect.NonDet

-- | An effect that eliminates a branch by causing the current branch
--   context of a non-deterministic computation to fail.
data Empty a

-- | Eliminates a branch by causing the current branch context of a
--   non-deterministic computation to fail.
[Empty] :: forall a. Empty a
type LEmpty = LiftFOE Empty
pattern LEmpty :: forall a f a1. () => (a ~ a1, ()) => LiftFOE Empty f a

-- | Eliminates a branch by causing the current branch context of a
--   non-deterministic computation to fail.
empty :: forall a f. SendFOE Empty f => f a

-- | Eliminates a branch by causing the current branch context of a
--   non-deterministic computation to fail.
empty' :: forall {k} (tag :: k) a f. SendFOE (Tag Empty tag) f => f a

-- | Eliminates a branch by causing the current branch context of a
--   non-deterministic computation to fail.
empty'' :: forall {k} (key :: k) a f. SendFOEBy key Empty f => f a

-- | An effect that splits the computation into two branches.
data Choose a

-- | Splits the computation into two branches. As a result of executing
--   <tt>choose</tt>, the world branches into one where <a>False</a> is
--   returned and one where <a>True</a> is returned.
[Choose] :: Choose Bool
type LChoose = LiftFOE Choose
pattern LChoose :: forall a f. () => (a ~ Bool, ()) => LiftFOE Choose f a

-- | Splits the computation into two branches. As a result of executing
--   <tt>choose</tt>, the world branches into one where <a>False</a> is
--   returned and one where <a>True</a> is returned.
choose :: SendFOE Choose f => f Bool

-- | Splits the computation into two branches. As a result of executing
--   <tt>choose</tt>, the world branches into one where <a>False</a> is
--   returned and one where <a>True</a> is returned.
choose' :: forall {k} (tag :: k) f. SendFOE (Tag Choose tag) f => f Bool

-- | Splits the computation into two branches. As a result of executing
--   <tt>choose</tt>, the world branches into one where <a>False</a> is
--   returned and one where <a>True</a> is returned.
choose'' :: forall {k} (key :: k) f. SendFOEBy key Choose f => f Bool

-- | An effect that executes two branches as scopes. A higher-order version
--   of the <a>Choose</a> effect.
data ChooseH (f :: Type -> Type) a

-- | Executes the given two scopes as branches. Even if one fails due to
--   the <a>empty</a> operation, the whole does not fail as long as the
--   other does not fail.
[ChooseH] :: forall (f :: Type -> Type) a. f a -> f a -> ChooseH f a

-- | Executes the given two scopes as branches. Even if one fails due to
--   the <a>empty</a> operation, the whole does not fail as long as the
--   other does not fail.
chooseH :: forall a f. SendHOE ChooseH f => f a -> f a -> f a

-- | Executes the given two scopes as branches. Even if one fails due to
--   the <a>empty</a> operation, the whole does not fail as long as the
--   other does not fail.
chooseH' :: forall {k} (tag :: k) a f. SendHOE (TagH ChooseH tag) f => f a -> f a -> f a

-- | Executes the given two scopes as branches. Even if one fails due to
--   the <a>empty</a> operation, the whole does not fail as long as the
--   other does not fail.
chooseH'' :: forall {k} (key :: k) a f. SendHOEBy key ChooseH f => f a -> f a -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.NonDet.ChooseH

module Data.Effect.Log
data Log msg a
[Log] :: forall msg. msg -> Log msg ()
type LLog msg = LiftFOE Log msg
pattern LLog :: forall a msg f. () => (a ~ (), ()) => msg -> LiftFOE (Log msg) f a
log :: SendFOE (Log msg) f => msg -> f ()
log' :: forall {k} (tag :: k) msg f. SendFOE (Tag (Log msg) tag) f => msg -> f ()
log'' :: forall {k} (key :: k) msg f. SendFOEBy key (Log msg) f => msg -> f ()


-- | This module provides the <a>Input</a> effect, comes from
--   <a><tt>Polysemy.Input</tt></a> in the <tt>polysemy</tt> package.
--   
--   Realizes input of values from the external world.
module Data.Effect.Input

-- | A general effect representing input of values from the external world.
data Input i a

-- | Retrieve a value input from the external world.
[Input] :: forall i. Input i i
type LInput i = LiftFOE Input i
pattern LInput :: forall a i f. () => (a ~ i, ()) => LiftFOE (Input i) f a

-- | Retrieve a value input from the external world.
input :: SendFOE (Input i) f => f i

-- | Retrieve a value input from the external world.
input' :: forall {k} (tag :: k) i f. SendFOE (Tag (Input i) tag) f => f i

-- | Retrieve a value input from the external world.
input'' :: forall {k} (key :: k) i f. SendFOEBy key (Input i) f => f i

-- | Returns the value obtained by transforming the input value using the
--   given function.
inputs :: (Input i <: f, Functor f) => (i -> a) -> f a


module Data.Effect.Fresh
data Fresh i a
[Fresh] :: forall i. Fresh i i
type LFresh i = LiftFOE Fresh i
pattern LFresh :: forall a i f. () => (a ~ i, ()) => LiftFOE (Fresh i) f a
fresh :: SendFOE (Fresh i) f => f i
fresh' :: forall {k} (tag :: k) i f. SendFOE (Tag (Fresh i) tag) f => f i
fresh'' :: forall {k} (key :: k) i f. SendFOEBy key (Fresh i) f => f i

module Data.Effect.Fix
data Fix (f :: Type -> Type) a
[Mfix] :: forall a (f :: Type -> Type). (a -> f a) -> Fix f a
mfix :: forall a f. SendHOE Fix f => (a -> f a) -> f a
mfix' :: forall {k} (tag :: k) a f. SendHOE (TagH Fix tag) f => (a -> f a) -> f a
mfix'' :: forall {k} (key :: k) a f. SendHOEBy key Fix f => (a -> f a) -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.Fix.Fix

module Data.Effect.Fail
data Fail a
[Fail] :: forall a. String -> Fail a
type LFail = LiftFOE Fail
pattern LFail :: forall a f a1. () => (a ~ a1, ()) => String -> LiftFOE Fail f a
fail :: forall a f. SendFOE Fail f => String -> f a
fail' :: forall {k} (tag :: k) a f. SendFOE (Tag Fail tag) f => String -> f a
fail'' :: forall {k} (key :: k) a f. SendFOEBy key Fail f => String -> f a


-- | An effect to escape from the normal control structure with an
--   exception value in the middle of a context.
module Data.Effect.Except

-- | An effect to escape from the normal control structure with an
--   exception value of type <tt>e</tt> in the middle of a context.
data Throw e a

-- | Throws an exception; that is, escapes from the normal control
--   structure with an exception value in the middle of a context.
[Throw] :: forall e a. e -> Throw e a

-- | An effect to catch exceptions.
data Catch e (f :: Type -> Type) a

-- | Catches exceptions within a scope and processes them according to the
--   given exception handler.
[Catch] :: forall (f :: Type -> Type) a e. f a -> (e -> f a) -> Catch e f a
type LThrow e = LiftFOE Throw e
pattern LThrow :: forall a e f a1. () => (a ~ a1, ()) => e -> LiftFOE (Throw e) f a

-- | Throws an exception; that is, escapes from the normal control
--   structure with an exception value in the middle of a context.
throw :: forall e a f. SendFOE (Throw e) f => e -> f a

-- | Throws an exception; that is, escapes from the normal control
--   structure with an exception value in the middle of a context.
throw' :: forall {k} (tag :: k) e a f. SendFOE (Tag (Throw e) tag) f => e -> f a

-- | Throws an exception; that is, escapes from the normal control
--   structure with an exception value in the middle of a context.
throw'' :: forall {k} (key :: k) e a f. SendFOEBy key (Throw e) f => e -> f a

-- | Catches exceptions within a scope and processes them according to the
--   given exception handler.
catch :: forall a e f. SendHOE (Catch e) f => f a -> (e -> f a) -> f a

-- | Catches exceptions within a scope and processes them according to the
--   given exception handler.
catch' :: forall {k} (tag :: k) a e f. SendHOE (TagH (Catch e) tag) f => f a -> (e -> f a) -> f a

-- | Catches exceptions within a scope and processes them according to the
--   given exception handler.
catch'' :: forall {k} (key :: k) a e f. SendHOEBy key (Catch e) f => f a -> (e -> f a) -> f a

-- | Throws the given <a>Either</a> value as an exception if it is
--   <a>Left</a>.
liftEither :: (Throw e <: f, Applicative f) => Either e a -> f a

-- | Throws the result of the given action as an exception if it is
--   <a>Left</a>.
joinEither :: (Throw e <: m, Monad m) => m (Either e a) -> m a

-- | If the given <a>Either</a> value is <a>Left</a>, execute it as an
--   action.
joinExcept :: Monad m => Either (m a) a -> m a

-- | If the result of the given action is <a>Left</a>, execute it as an
--   action.
exc :: Monad m => m (Either (m a) a) -> m a

-- | If an exception occurs, executes the given exception handler, but the
--   exception is not stopped there and is rethrown.
withExcept :: (Catch e <<: f, Throw e <: f, Applicative f) => f a -> (e -> f ()) -> f a

-- | If an exception occurs, executes the specified action, but the
--   exception is not stopped there and is rethrown.
onExcept :: (Catch e <<: f, Throw e <: f, Applicative f) => f a -> f () -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Except.Catch e)


-- | This module provides the <a>KVStore</a> effect, comes from
--   <a><tt>Polysemy.KVStore</tt></a> in the <tt>polysemy-kvstore</tt>
--   package.
module Data.Effect.KVStore
data KVStore k v a
[LookupKV] :: forall k v. k -> KVStore k v (Maybe v)
[UpdateKV] :: forall k v. k -> Maybe v -> KVStore k v ()
type LKVStore k v = LiftFOE KVStore k v
pattern LUpdateKV :: forall a k v f. () => (a ~ (), ()) => k -> Maybe v -> LiftFOE (KVStore k v) f a
pattern LLookupKV :: forall a v k f. () => (a ~ Maybe v, ()) => k -> LiftFOE (KVStore k v) f a
lookupKV :: SendFOE (KVStore k v) f => k -> f (Maybe v)
lookupKV' :: forall {k1} (tag :: k1) k2 v f. SendFOE (Tag (KVStore k2 v) tag) f => k2 -> f (Maybe v)
lookupKV'' :: forall {k1} (key :: k1) k2 v f. SendFOEBy key (KVStore k2 v) f => k2 -> f (Maybe v)
updateKV :: SendFOE (KVStore k v) f => k -> Maybe v -> f ()
updateKV' :: forall {k1} (tag :: k1) k2 v f. SendFOE (Tag (KVStore k2 v) tag) f => k2 -> Maybe v -> f ()
updateKV'' :: forall {k1} (key :: k1) k2 v f. SendFOEBy key (KVStore k2 v) f => k2 -> Maybe v -> f ()
lookupOrThrowKV :: (KVStore k v <: m, Throw e <: m, Monad m) => (k -> e) -> k -> m v
existsKV :: forall v k f. (KVStore k v <: f, Functor f) => k -> f Bool
writeKV :: KVStore k v <: f => k -> v -> f ()
deleteKV :: forall v k f. KVStore k v <: f => k -> f ()
modifyKV :: (KVStore k v <: m, Monad m) => v -> (v -> v) -> k -> m ()


-- | This module provides effects for the coroutine, comes from
--   <a><tt>Control.Monad.Freer.Coroutine</tt></a> in the
--   <tt>freer-simple</tt> package (The continuation part <tt>(b -&gt;
--   c)</tt> has been removed. If necessary, please manually compose the
--   <a>Coyoneda</a>) .
module Data.Effect.Coroutine

-- | An effect for coroutines. Realizes an operation that transfers control
--   to the caller of the computation with coroutines along with a value of
--   type <tt>a</tt>, and receives a value of type <tt>b</tt> from the
--   caller.
data Yield a b c

-- | Transfers control to the caller of the computation with coroutines
--   along with a value of type <tt>a</tt>, and receives a value of type
--   <tt>b</tt> from the caller.
[Yield] :: forall a b. a -> Yield a b b
type LYield a b = LiftFOE Yield a b
pattern LYield :: forall a1 b a2 f. () => (a1 ~ b, ()) => a2 -> LiftFOE (Yield a2 b) f a1

-- | Transfers control to the caller of the computation with coroutines
--   along with a value of type <tt>a</tt>, and receives a value of type
--   <tt>b</tt> from the caller.
yield :: SendFOE (Yield a b) f => a -> f b

-- | Transfers control to the caller of the computation with coroutines
--   along with a value of type <tt>a</tt>, and receives a value of type
--   <tt>b</tt> from the caller.
yield' :: forall {k} (tag :: k) a b f. SendFOE (Tag (Yield a b) tag) f => a -> f b

-- | Transfers control to the caller of the computation with coroutines
--   along with a value of type <tt>a</tt>, and receives a value of type
--   <tt>b</tt> from the caller.
yield'' :: forall {k} (key :: k) a b f. SendFOEBy key (Yield a b) f => a -> f b

-- | A version of <a>yield</a> where the value returned from the caller of
--   the computation with coroutines is unit.
yield_ :: Yield a () <: f => a -> f ()

-- | The execution result when handling a computation that includes the
--   <a>Yield</a> effect. A computation that may include suspension. If the
--   computation does not include <a>yield</a>, the completed result of the
--   computation is obtained as <a>Done</a>. If the computation includes
--   <a>yield</a>, execution is suspended at that point, and the value of
--   type <tt>a</tt> thrown by <a>yield</a> and the continuation of the
--   computation from the point of <a>yield</a> are obtained as
--   <a>Continue</a>. By re-executing this continuation, you can resume the
--   computation.
data Status (f :: Type -> Type) a b r

-- | The computation has completely finished
Done :: r -> Status (f :: Type -> Type) a b r

-- | The computation has been suspended by <a>yield</a>
Continue :: a -> (b -> f (Status f a b r)) -> Status (f :: Type -> Type) a b r

-- | Extends the computation result by appending the specified
--   continuation.
continueStatus :: Monad m => (x -> m (Status m a b r)) -> Status m a b x -> m (Status m a b r)

-- | Repeats the computation until the final result is obtained by
--   continuing the computation using the specified handler each time it
--   suspends.
loopStatus :: Monad m => (a -> m b) -> Status m a b r -> m r
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Effect.Coroutine.Status f a b)

module Data.Effect.Cont
data CallCC (m :: Type -> Type) a
[CallCC] :: forall a (m :: Type -> Type). (forall r. () => (a -> m r) -> m a) -> CallCC m a
callCC :: forall a m. SendHOE CallCC m => (forall r. () => (a -> m r) -> m a) -> m a
callCC' :: forall {k} (tag :: k) a m. SendHOE (TagH CallCC tag) m => (forall r. () => (a -> m r) -> m a) -> m a
callCC'' :: forall {k} (key :: k) a m. SendHOEBy key CallCC m => (forall r. () => (a -> m r) -> m a) -> m a


-- | Effects for controlling time-related operations.
module Data.Effect.Concurrent.Timer

-- | An effect for time-related operations.
data Timer a

-- | Retrieves the current relative time from an arbitrary fixed reference
--   point. The reference point does not change within the context of that
--   scope.
[Clock] :: Timer DiffTime

-- | Temporarily suspends computation for the specified duration.
[Sleep] :: DiffTime -> Timer ()
type LTimer = LiftFOE Timer
pattern LSleep :: forall a f. () => (a ~ (), ()) => DiffTime -> LiftFOE Timer f a
pattern LClock :: forall a f. () => (a ~ DiffTime, ()) => LiftFOE Timer f a

-- | Retrieves the current relative time from an arbitrary fixed reference
--   point. The reference point does not change within the context of that
--   scope.
clock :: SendFOE Timer f => f DiffTime

-- | Retrieves the current relative time from an arbitrary fixed reference
--   point. The reference point does not change within the context of that
--   scope.
clock' :: forall {k} (tag :: k) f. SendFOE (Tag Timer tag) f => f DiffTime

-- | Retrieves the current relative time from an arbitrary fixed reference
--   point. The reference point does not change within the context of that
--   scope.
clock'' :: forall {k} (key :: k) f. SendFOEBy key Timer f => f DiffTime

-- | Temporarily suspends computation for the specified duration.
sleep :: SendFOE Timer f => DiffTime -> f ()

-- | Temporarily suspends computation for the specified duration.
sleep' :: forall {k} (tag :: k) f. SendFOE (Tag Timer tag) f => DiffTime -> f ()

-- | Temporarily suspends computation for the specified duration.
sleep'' :: forall {k} (key :: k) f. SendFOEBy key Timer f => DiffTime -> f ()

-- | Creates a scope where elapsed time can be obtained. An action to
--   retrieve the elapsed time, re-zeroed at the start of the scope, is
--   passed to the scope.
withElapsedTime :: (Timer <: m, Monad m) => (m DiffTime -> m a) -> m a

-- | Returns the time taken for a computation along with the result as a
--   pair.
measureTime :: (Timer <: m, Monad m) => m a -> m (DiffTime, a)

-- | Temporarily suspends computation until the relative time from the
--   fixed reference point in the current scope's context, as given by the
--   argument. If the specified resume time has already passed, returns the
--   elapsed time (positive value) in <a>Just</a>.
sleepUntil :: (Timer <: m, Monad m) => DiffTime -> m (Maybe DiffTime)

-- | Repeats a computation indefinitely. Controls so that each loop occurs
--   at a specific time interval. If the computation time exceeds and the
--   requested interval cannot be realized, the excess delay occurs, which
--   accumulates and is not canceled.
runCyclic :: (Timer <: m, Monad m) => m DiffTime -> m () -> m a

-- | Controls to repeat a specified computation at fixed time intervals. A
--   specialized version of <a>runCyclic</a>. If the computation time
--   exceeds and the requested interval cannot be realized, the excess
--   delay occurs, which accumulates and is not canceled.
runPeriodic :: (Timer <: m, Monad m) => DiffTime -> m () -> m a

-- | Calls <a>yield</a> of a coroutine at fixed intervals. If the
--   computation time exceeds and the requested interval cannot be
--   realized, the excess delay occurs, which accumulates and is not
--   canceled.
periodicTimer :: (Timer <: m, Yield () () <: m, Monad m) => DiffTime -> m a

-- | Calls <a>yield</a> of a coroutine at specific intervals. Controls so
--   that the time returned by <a>yield</a> becomes the time interval until
--   the next loop. If the computation time exceeds and the requested
--   interval cannot be realized, the excess delay occurs, which
--   accumulates and is not canceled.
cyclicTimer :: (Timer <: m, Yield () DiffTime <: m, Monad m) => m a

-- | An effect that realizes control of wait times such that the specified
--   time becomes the interval until the next <tt>wait</tt> when
--   <tt>wait</tt> is executed repeatedly.
data CyclicTimer a

-- | Controls the wait time so that when <tt>wait</tt> is executed
--   repeatedly, the specified time becomes the interval until the next
--   <tt>wait</tt>.
[Wait] :: DiffTime -> CyclicTimer ()
type LCyclicTimer = LiftFOE CyclicTimer
pattern LWait :: forall a f. () => (a ~ (), ()) => DiffTime -> LiftFOE CyclicTimer f a

-- | Controls the wait time so that when <tt>wait</tt> is executed
--   repeatedly, the specified time becomes the interval until the next
--   <tt>wait</tt>.
wait :: SendFOE CyclicTimer f => DiffTime -> f ()

-- | Controls the wait time so that when <tt>wait</tt> is executed
--   repeatedly, the specified time becomes the interval until the next
--   <tt>wait</tt>.
wait' :: forall {k} (tag :: k) f. SendFOE (Tag CyclicTimer tag) f => DiffTime -> f ()

-- | Controls the wait time so that when <tt>wait</tt> is executed
--   repeatedly, the specified time becomes the interval until the next
--   <tt>wait</tt>.
wait'' :: forall {k} (key :: k) f. SendFOEBy key CyclicTimer f => DiffTime -> f ()


-- | Effects for parallel computations.
module Data.Effect.Concurrent.Parallel

-- | An <a>Applicative</a>-based effect for executing computations in
--   parallel.
data Parallel (f :: Type -> Type) a

-- | Executes two actions in parallel and blocks until both are complete.
--   Finally, aggregates the execution results based on the specified
--   function.
[LiftP2] :: forall a1 b a (f :: Type -> Type). (a1 -> b -> a) -> f a1 -> f b -> Parallel f a

-- | An effect that blocks a computation indefinitely.
data Halt a

-- | Blocks a computation indefinitely.
[Halt] :: forall a. Halt a

-- | An effect that adopts the result of the computation that finishes
--   first among two computations and cancels the other.
data Race (f :: Type -> Type) a

-- | Adopts the result of the computation that finishes first among two
--   computations and cancels the other.
[Race] :: forall (f :: Type -> Type) a. f a -> f a -> Race f a
type LHalt = LiftFOE Halt
pattern LHalt :: forall a f a1. () => (a ~ a1, ()) => LiftFOE Halt f a

-- | Blocks a computation indefinitely.
halt :: forall a f. SendFOE Halt f => f a

-- | Blocks a computation indefinitely.
halt' :: forall {k} (tag :: k) a f. SendFOE (Tag Halt tag) f => f a

-- | Blocks a computation indefinitely.
halt'' :: forall {k} (key :: k) a f. SendFOEBy key Halt f => f a

-- | Executes two actions in parallel and blocks until both are complete.
--   Finally, aggregates the execution results based on the specified
--   function.
liftP2 :: forall a b c f. SendHOE Parallel f => (a -> b -> c) -> f a -> f b -> f c

-- | Executes two actions in parallel and blocks until both are complete.
--   Finally, aggregates the execution results based on the specified
--   function.
liftP2' :: forall {k} (tag :: k) a b c f. SendHOE (TagH Parallel tag) f => (a -> b -> c) -> f a -> f b -> f c

-- | Executes two actions in parallel and blocks until both are complete.
--   Finally, aggregates the execution results based on the specified
--   function.
liftP2'' :: forall {k} (key :: k) a b c f. SendHOEBy key Parallel f => (a -> b -> c) -> f a -> f b -> f c

-- | Adopts the result of the computation that finishes first among two
--   computations and cancels the other.
race :: forall a f. SendHOE Race f => f a -> f a -> f a

-- | Adopts the result of the computation that finishes first among two
--   computations and cancels the other.
race' :: forall {k} (tag :: k) a f. SendHOE (TagH Race tag) f => f a -> f a -> f a

-- | Adopts the result of the computation that finishes first among two
--   computations and cancels the other.
race'' :: forall {k} (key :: k) a f. SendHOEBy key Race f => f a -> f a -> f a

-- | A wrapper that allows using the <a>Parallel</a> effect in the form of
--   <a>Applicative</a> / <a>Alternative</a> instances.
newtype Concurrently (f :: k -> Type) (a :: k)
Concurrently :: f a -> Concurrently (f :: k -> Type) (a :: k)
[runConcurrently] :: Concurrently (f :: k -> Type) (a :: k) -> f a

-- | Executes three actions in parallel and blocks until all are complete.
--   Finally, aggregates the execution results based on the specified
--   function.
liftP3 :: (Parallel <<: f, Applicative f) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

-- | An effect that realizes polling and cancellation of actions running in
--   parallel.
data Poll (f :: Type -> Type) a

-- | Performs polling on an action running in parallel in the form of a
--   fold.
--   
--   First, the parallel execution of two actions begins.
--   
--   When the execution of the first action completes, polling on the
--   second action is performed at that point, and the result is passed to
--   the folding function. If the function returns <a>Left</a>, the folding
--   terminates and it becomes the final result. If the second action is
--   not yet complete, it is canceled. If the function returns
--   <a>Right</a>, the folding continues, and the same process repeats.
[Poldl] :: forall a1 b (f :: Type -> Type) a. (a1 -> Maybe b -> f (Either a a1)) -> f a1 -> f b -> Poll f a

-- | Performs polling on an action running in parallel in the form of a
--   fold.
--   
--   First, the parallel execution of two actions begins.
--   
--   When the execution of the first action completes, polling on the
--   second action is performed at that point, and the result is passed to
--   the folding function. If the function returns <a>Left</a>, the folding
--   terminates and it becomes the final result. If the second action is
--   not yet complete, it is canceled. If the function returns
--   <a>Right</a>, the folding continues, and the same process repeats.
poldl :: forall a b r f. SendHOE Poll f => (a -> Maybe b -> f (Either r a)) -> f a -> f b -> f r

-- | Performs polling on an action running in parallel in the form of a
--   fold.
--   
--   First, the parallel execution of two actions begins.
--   
--   When the execution of the first action completes, polling on the
--   second action is performed at that point, and the result is passed to
--   the folding function. If the function returns <a>Left</a>, the folding
--   terminates and it becomes the final result. If the second action is
--   not yet complete, it is canceled. If the function returns
--   <a>Right</a>, the folding continues, and the same process repeats.
poldl' :: forall {k} (tag :: k) a b r f. SendHOE (TagH Poll tag) f => (a -> Maybe b -> f (Either r a)) -> f a -> f b -> f r

-- | Performs polling on an action running in parallel in the form of a
--   fold.
--   
--   First, the parallel execution of two actions begins.
--   
--   When the execution of the first action completes, polling on the
--   second action is performed at that point, and the result is passed to
--   the folding function. If the function returns <a>Left</a>, the folding
--   terminates and it becomes the final result. If the second action is
--   not yet complete, it is canceled. If the function returns
--   <a>Right</a>, the folding continues, and the same process repeats.
poldl'' :: forall {k} (key :: k) a b r f. SendHOEBy key Poll f => (a -> Maybe b -> f (Either r a)) -> f a -> f b -> f r

-- | Executes two actions in parallel. If the first action completes before
--   the second, the second action is canceled.
cancels :: (Poll <<: f, Applicative f) => f a -> f b -> f (a, Maybe b)

-- | Executes two actions in parallel. If the second action completes
--   before the first, the first action is canceled.
cancelBy :: (Poll <<: f, Applicative f) => f a -> f b -> f (Maybe a, b)

-- | An effect for parallel computations based on a <a>Traversable</a>
--   container <tt>t</tt>.
data For (t :: Type -> Type) (f :: Type -> Type) a

-- | Executes in parallel the actions stored within a <a>Traversable</a>
--   container <tt>t</tt>.
[For] :: forall (t :: Type -> Type) (f :: Type -> Type) a1. t (f a1) -> For t f (t a1)

-- | Executes in parallel the actions stored within a <a>Traversable</a>
--   container <tt>t</tt>.
for :: forall t a f. SendHOE (For t) f => t (f a) -> f (t a)

-- | Executes in parallel the actions stored within a <a>Traversable</a>
--   container <tt>t</tt>.
for' :: forall {k} (tag :: k) t a f. SendHOE (TagH (For t) tag) f => t (f a) -> f (t a)

-- | Executes in parallel the actions stored within a <a>Traversable</a>
--   container <tt>t</tt>.
for'' :: forall {k} (key :: k) t a f. SendHOEBy key (For t) f => t (f a) -> f (t a)

-- | Converts the <a>Traversable</a> container-based parallel computation
--   effect <a>For</a> into the <a>Applicative</a>-based parallel
--   computation effect <a>Parallel</a>.
forToParallel :: forall (f :: Type -> Type) (t :: Type -> Type). (Parallel <<: f, Traversable t, Applicative f) => For t f ~> f
instance (Data.Effect.Concurrent.Parallel.Race Control.Effect.<<: f, Data.Effect.Concurrent.Parallel.Halt Control.Effect.<: f, Data.Effect.Concurrent.Parallel.Parallel Control.Effect.<<: f, GHC.Base.Applicative f) => GHC.Base.Alternative (Data.Effect.Concurrent.Parallel.Concurrently f)
instance (Data.Effect.Concurrent.Parallel.Parallel Control.Effect.<<: f, GHC.Base.Applicative f) => GHC.Base.Applicative (Data.Effect.Concurrent.Parallel.Concurrently f)
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Effect.Concurrent.Parallel.Concurrently f)
instance GHC.Base.Functor t => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Concurrent.Parallel.For t)
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.Concurrent.Parallel.Parallel
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.Concurrent.Parallel.Poll
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor Data.Effect.Concurrent.Parallel.Race

module Data.Effect.Chronicle
data ChronicleF c a
[Dictate] :: forall c. c -> ChronicleF c ()
[Confess] :: forall c a. c -> ChronicleF c a
data ChronicleH c (f :: Type -> Type) a
[Memento] :: forall (f :: Type -> Type) a1 c. f a1 -> ChronicleH c f (Either c a1)
[Absolve] :: forall a (f :: Type -> Type) c. a -> f a -> ChronicleH c f a
[Condemn] :: forall (f :: Type -> Type) a c. f a -> ChronicleH c f a
type LChronicleF c = LiftFOE ChronicleF c
pattern LConfess :: forall a c f a1. () => (a ~ a1, ()) => c -> LiftFOE (ChronicleF c) f a
pattern LDictate :: forall a c f. () => (a ~ (), ()) => c -> LiftFOE (ChronicleF c) f a
dictate :: SendFOE (ChronicleF c) f => c -> f ()
dictate' :: forall {k} (tag :: k) c f. SendFOE (Tag (ChronicleF c) tag) f => c -> f ()
dictate'' :: forall {k} (key :: k) c f. SendFOEBy key (ChronicleF c) f => c -> f ()
confess :: forall c a f. SendFOE (ChronicleF c) f => c -> f a
confess' :: forall {k} (tag :: k) c a f. SendFOE (Tag (ChronicleF c) tag) f => c -> f a
confess'' :: forall {k} (key :: k) c a f. SendFOEBy key (ChronicleF c) f => c -> f a
memento :: forall a c f. SendHOE (ChronicleH c) f => f a -> f (Either c a)
memento' :: forall {k} (tag :: k) a c f. SendHOE (TagH (ChronicleH c) tag) f => f a -> f (Either c a)
memento'' :: forall {k} (key :: k) a c f. SendHOEBy key (ChronicleH c) f => f a -> f (Either c a)
absolve :: forall a c f. SendHOE (ChronicleH c) f => a -> f a -> f a
absolve' :: forall {k} (tag :: k) a c f. SendHOE (TagH (ChronicleH c) tag) f => a -> f a -> f a
absolve'' :: forall {k} (key :: k) a c f. SendHOEBy key (ChronicleH c) f => a -> f a -> f a
condemn :: forall a c f. SendHOE (ChronicleH c) f => f a -> f a
condemn' :: forall {k} (tag :: k) a c f. SendHOE (TagH (ChronicleH c) tag) f => f a -> f a
condemn'' :: forall {k} (key :: k) a c f. SendHOEBy key (ChronicleH c) f => f a -> f a
chronicle :: (ChronicleF c <: f, Applicative f) => These c a -> f a
instance (() :: Constraint) => Data.Comp.Multi.HFunctor.HFunctor (Data.Effect.Chronicle.ChronicleH c)


module Data.Effect.Accum
data Accum w a
[Add] :: forall w1 w. w1 -> Accum w ()
[Look] :: forall w. Accum w w
type LAccum w = LiftFOE Accum w
pattern LLook :: forall a w f. () => (a ~ w, ()) => LiftFOE (Accum w) f a
pattern LAdd :: forall a f1 f2 w. () => (a ~ (), ()) => w -> LiftFOE (Accum f1) f2 a
add :: forall w f1 f2. SendFOE (Accum f1) f2 => w -> f2 ()
add' :: forall {k} (tag :: k) w f1 f2. SendFOE (Tag (Accum f1) tag) f2 => w -> f2 ()
add'' :: forall {k} (key :: k) w f1 f2. SendFOEBy key (Accum f1) f2 => w -> f2 ()
look :: SendFOE (Accum w) f => f w
look' :: forall {k} (tag :: k) w f. SendFOE (Tag (Accum w) tag) f => f w
look'' :: forall {k} (key :: k) w f. SendFOEBy key (Accum w) f => f w