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


-- | A fast, flexible, fused effect system.
--   
--   A fast, flexible, fused effect system, à la Effect Handlers in Scope,
--   Monad Transformers and Modular Algebraic Effects: What Binds Them
--   Together, and Fusion for Free—Efficient Algebraic Effect Handlers.
@package fused-effects
@version 0.1.2.1

module Control.Effect.Carrier
class HFunctor h

-- | Functor map. This is required to be <a>fmap</a>.
--   
--   This can go away once we have quantified constraints.
fmap' :: HFunctor h => (a -> b) -> h m a -> h m b

-- | Functor map. This is required to be <a>fmap</a>.
--   
--   This can go away once we have quantified constraints.
fmap' :: (HFunctor h, Functor (h m)) => (a -> b) -> h m a -> h m b

-- | Higher-order functor map of a natural transformation over higher-order
--   positions within the effect.
hmap :: HFunctor h => (forall x. m x -> n x) -> h m a -> h n a

-- | The class of effect types, which must:
--   
--   <ol>
--   <li>Be functorial in their last two arguments, and</li>
--   <li>Support threading effects in higher-order positions through using
--   the carrier’s suspended state.</li>
--   </ol>
class HFunctor sig => Effect sig

-- | Handle any effects in a signature by threading the carrier’s state all
--   the way through to the continuation.
handle :: (Effect sig, Functor f) => f () -> (forall x. f (m x) -> n (f x)) -> sig m (m a) -> sig n (n (f a))

-- | The class of carriers (results) for algebras (effect handlers) over
--   signatures (effects), whose actions are given by the <a>ret</a> and
--   <a>eff</a> methods.
class HFunctor sig => Carrier sig h | h -> sig

-- | Wrap a return value.
ret :: Carrier sig h => a -> h a

-- | Construct a value in the carrier for an effect signature (typically a
--   sum of a handled effect and any remaining effects).
eff :: Carrier sig h => sig h (h a) -> h a

-- | Apply a handler specified as a natural transformation to both
--   higher-order and continuation positions within an <a>HFunctor</a>.
handlePure :: HFunctor sig => (forall x. f x -> g x) -> sig f (f a) -> sig g (g a)

-- | Thread a <a>Coercible</a> carrier through an <a>HFunctor</a>.
--   
--   This is applicable whenever <tt>f</tt> is <a>Coercible</a> to
--   <tt>g</tt>, e.g. simple <tt>newtype</tt>s.
handleCoercible :: (HFunctor sig, Coercible f g) => sig f (f a) -> sig g (g a)

-- | Thread a <tt>Reader</tt>-like carrier through an <a>HFunctor</a>.
handleReader :: HFunctor sig => r -> (forall x. f x -> r -> g x) -> sig f (f a) -> sig g (g a)

-- | Thread a <tt>State</tt>-like carrier through an <a>Effect</a>.
handleState :: Effect sig => s -> (forall x. f x -> s -> g (s, x)) -> sig f (f a) -> sig g (g (s, a))

-- | Thread a carrier producing <a>Either</a>s through an <a>Effect</a>.
handleEither :: (Carrier sig g, Effect sig) => (forall x. f x -> g (Either e x)) -> sig f (f a) -> sig g (g (Either e a))

-- | Thread a carrier producing values in a <a>Traversable</a> <a>Monad</a>
--   (e.g. '[]') through an <a>Effect</a>.
handleTraversable :: (Effect sig, Applicative g, Monad m, Traversable m) => (forall x. f x -> g (m x)) -> sig f (f a) -> sig g (g (m a))

module Control.Effect.Fail.Internal
newtype Fail (m :: * -> *) k
Fail :: String -> Fail k
instance GHC.Base.Functor (Control.Effect.Fail.Internal.Fail m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Fail.Internal.Fail
instance Control.Effect.Carrier.Effect Control.Effect.Fail.Internal.Fail

module Control.Effect.Lift.Internal
newtype Lift sig (m :: * -> *) k
Lift :: sig k -> Lift sig k
[unLift] :: Lift sig k -> sig k
instance GHC.Base.Functor sig => GHC.Base.Functor (Control.Effect.Lift.Internal.Lift sig m)
instance GHC.Base.Functor sig => Control.Effect.Carrier.HFunctor (Control.Effect.Lift.Internal.Lift sig)
instance GHC.Base.Functor sig => Control.Effect.Carrier.Effect (Control.Effect.Lift.Internal.Lift sig)

module Control.Effect.NonDet.Internal
data NonDet (m :: * -> *) k
Empty :: NonDet k
Choose :: (Bool -> k) -> NonDet k

-- | The result of a nondeterministic branch of a computation.
--   
--   <a>Branch</a> can be used to define <a>NonDet</a> carriers which
--   control nondeterminism in some specific way, e.g. pruning branches
--   according to some specific heuristic.
data Branch m e a
None :: e -> Branch m e a
Pure :: a -> Branch m e a
Alt :: m a -> m a -> Branch m e a

-- | Case analysis for <a>Branch</a>, taking a value to use for
--   <tt>Cut</tt>, a value to use for <a>None</a>, and a function to apply
--   to the contents of <a>Pure</a>.
--   
--   <pre>
--   branch None Pure Alt a == (a :: Branch e [] a)
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (None a :: Branch [] a) == applyFun f a
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (Pure a :: Branch [] a) == applyFun g a
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (Alt a b :: Branch [] a) == applyFun2 h a b
--   </pre>
branch :: (e -> a) -> (b -> a) -> (m b -> m b -> a) -> Branch m e b -> a

-- | Interpret a <a>Branch</a> into an underlying <a>Alternative</a>
--   context.
runBranch :: Alternative m => (e -> m a) -> Branch m e a -> m a
instance Data.Traversable.Traversable m => Data.Traversable.Traversable (Control.Effect.NonDet.Internal.Branch m e)
instance (GHC.Show.Show e, GHC.Show.Show a, GHC.Show.Show (m a)) => GHC.Show.Show (Control.Effect.NonDet.Internal.Branch m e a)
instance (GHC.Classes.Ord e, GHC.Classes.Ord a, GHC.Classes.Ord (m a)) => GHC.Classes.Ord (Control.Effect.NonDet.Internal.Branch m e a)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Effect.NonDet.Internal.Branch m e)
instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Control.Effect.NonDet.Internal.Branch m e)
instance (GHC.Classes.Eq e, GHC.Classes.Eq a, GHC.Classes.Eq (m a)) => GHC.Classes.Eq (Control.Effect.NonDet.Internal.Branch m e a)
instance GHC.Base.Functor (Control.Effect.NonDet.Internal.NonDet m)
instance Control.Effect.Carrier.HFunctor Control.Effect.NonDet.Internal.NonDet
instance Control.Effect.Carrier.Effect Control.Effect.NonDet.Internal.NonDet

module Control.Effect.Random.Internal
data Random m k
Random :: (a -> k) -> Random m k
RandomR :: (a, a) -> (a -> k) -> Random m k
Interleave :: m a -> (a -> k) -> Random m k
instance GHC.Base.Functor (Control.Effect.Random.Internal.Random m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Random.Internal.Random
instance Control.Effect.Carrier.Effect Control.Effect.Random.Internal.Random

module Control.Effect.Sum
data ( f :+: g ) (m :: * -> *) k
L :: f m k -> (:+:) f g k
R :: g m k -> (:+:) f g k
infixr 4 :+:

-- | Lift algebras for either side of a sum into a single algebra on sums.
--   
--   Note that the order of the functions is the opposite of members of the
--   sum. This is more convenient for defining effect handlers as lambdas
--   (especially using <tt>-XLambdaCase</tt>) on the right, enabling better
--   error messaging when using typed holes than would be the case with a
--   binding in a where clause.
handleSum :: (sig2 m a -> b) -> (sig1 m a -> b) -> (sig1 :+: sig2) m a -> b
class Member (sub :: (* -> *) -> (* -> *)) sup
inj :: Member sub sup => sub m a -> sup m a
prj :: Member sub sup => sup m a -> Maybe (sub m a)

-- | Construct a request for an effect to be interpreted by some handler
--   later on.
send :: (Member effect sig, Carrier sig m) => effect m (m a) -> m a
instance (GHC.Show.Show (f m k), GHC.Show.Show (g m k)) => GHC.Show.Show ((Control.Effect.Sum.:+:) f g m k)
instance (GHC.Classes.Ord (f m k), GHC.Classes.Ord (g m k)) => GHC.Classes.Ord ((Control.Effect.Sum.:+:) f g m k)
instance (GHC.Base.Functor (f m), GHC.Base.Functor (g m)) => GHC.Base.Functor ((Control.Effect.Sum.:+:) f g m)
instance (GHC.Classes.Eq (f m k), GHC.Classes.Eq (g m k)) => GHC.Classes.Eq ((Control.Effect.Sum.:+:) f g m k)
instance Control.Effect.Sum.Member sub sub
instance Control.Effect.Sum.Member sub (sub Control.Effect.Sum.:+: sup)
instance Control.Effect.Sum.Member sub sup => Control.Effect.Sum.Member sub (sub' Control.Effect.Sum.:+: sup)
instance (Control.Effect.Carrier.HFunctor l, Control.Effect.Carrier.HFunctor r) => Control.Effect.Carrier.HFunctor (l Control.Effect.Sum.:+: r)
instance (Control.Effect.Carrier.Effect l, Control.Effect.Carrier.Effect r) => Control.Effect.Carrier.Effect (l Control.Effect.Sum.:+: r)

module Control.Effect.Internal
newtype Eff carrier a
Eff :: (forall x. (a -> carrier x) -> carrier x) -> Eff carrier a
[unEff] :: Eff carrier a -> forall x. (a -> carrier x) -> carrier x
runEff :: (a -> carrier b) -> Eff carrier a -> carrier b
interpret :: Carrier sig carrier => Eff carrier a -> carrier a
instance GHC.Base.Functor (Control.Effect.Internal.Eff carrier)
instance GHC.Base.Applicative (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member Control.Effect.NonDet.Internal.NonDet sig, Control.Effect.Carrier.Carrier sig carrier) => GHC.Base.Alternative (Control.Effect.Internal.Eff carrier)
instance GHC.Base.Monad (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member Control.Effect.Fail.Internal.Fail sig, Control.Effect.Carrier.Carrier sig carrier) => Control.Monad.Fail.MonadFail (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member Control.Effect.NonDet.Internal.NonDet sig, Control.Effect.Carrier.Carrier sig carrier) => GHC.Base.MonadPlus (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member (Control.Effect.Lift.Internal.Lift GHC.Types.IO) sig, Control.Effect.Carrier.Carrier sig carrier) => Control.Monad.IO.Class.MonadIO (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member Control.Effect.Random.Internal.Random sig, Control.Effect.Carrier.Carrier sig carrier) => Control.Monad.Random.Class.MonadRandom (Control.Effect.Internal.Eff carrier)
instance (Control.Effect.Sum.Member Control.Effect.Random.Internal.Random sig, Control.Effect.Carrier.Carrier sig carrier) => Control.Monad.Random.Class.MonadInterleave (Control.Effect.Internal.Eff carrier)
instance Control.Effect.Carrier.Carrier sig carrier => Control.Effect.Carrier.Carrier sig (Control.Effect.Internal.Eff carrier)

module Control.Effect.State
data State s (m :: * -> *) k
Get :: (s -> k) -> State s k
Put :: s -> k -> State s k

-- | Get the current state value.
--   
--   <pre>
--   snd (run (runState a get)) == a
--   </pre>
get :: (Member (State s) sig, Carrier sig m) => m s

-- | Project a function out of the current state value.
--   
--   <pre>
--   snd (run (runState a (gets (applyFun f)))) == applyFun f a
--   </pre>
gets :: (Member (State s) sig, Carrier sig m, Functor m) => (s -> a) -> m a

-- | Replace the state value with a new value.
--   
--   <pre>
--   fst (run (runState a (put b))) == b
--   </pre>
--   
--   <pre>
--   snd (run (runState a (get &lt;* put b))) == a
--   </pre>
--   
--   <pre>
--   snd (run (runState a (put b *&gt; get))) == b
--   </pre>
put :: (Member (State s) sig, Carrier sig m) => s -> m ()

-- | Replace the state value with the result of applying a function to the
--   current state value. This is strict in the new state; if you need
--   laziness, use <tt>get &gt;&gt;= put . f</tt>.
--   
--   <pre>
--   fst (run (runState a (modify (+1)))) == (1 + a :: Integer)
--   </pre>
modify :: (Member (State s) sig, Carrier sig m, Monad m) => (s -> s) -> m ()

-- | Run a <a>State</a> effect starting from the passed value.
--   
--   <pre>
--   run (runState a (pure b)) == (a, b)
--   </pre>
runState :: (Carrier sig m, Effect sig) => s -> Eff (StateC s m) a -> m (s, a)

-- | Run a <a>State</a> effect, yielding the result value and discarding
--   the final state.
--   
--   <pre>
--   run (evalState a (pure b)) == b
--   </pre>
evalState :: (Carrier sig m, Effect sig, Functor m) => s -> Eff (StateC s m) a -> m a

-- | Run a <a>State</a> effect, yielding the final state and discarding the
--   return value.
--   
--   <pre>
--   run (execState a (pure b)) == a
--   </pre>
execState :: (Carrier sig m, Effect sig, Functor m) => s -> Eff (StateC s m) a -> m s
newtype StateC s m a
StateC :: (s -> m (s, a)) -> StateC s m a
[runStateC] :: StateC s m a -> s -> m (s, a)
instance GHC.Base.Functor (Control.Effect.State.State s m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig) => Control.Effect.Carrier.Carrier (Control.Effect.State.State s Control.Effect.Sum.:+: sig) (Control.Effect.State.StateC s m)
instance Control.Effect.Carrier.HFunctor (Control.Effect.State.State s)
instance Control.Effect.Carrier.Effect (Control.Effect.State.State s)

module Control.Effect.Resumable

-- | Errors which can be resumed with values of some
--   existentially-quantified type.
data Resumable err (m :: * -> *) k
Resumable :: err a -> (a -> k) -> Resumable err k

-- | Throw an error which can be resumed with a value of its result type.
--   
--   <pre>
--   run (runResumable (throwResumable (Identity a))) == Left (SomeError (Identity a))
--   </pre>
throwResumable :: (Member (Resumable err) sig, Carrier sig m) => err a -> m a

-- | An error at some existentially-quantified type index.
data SomeError (err :: * -> *)
SomeError :: err a -> SomeError

-- | Run a <a>Resumable</a> effect, returning uncaught errors in
--   <a>Left</a> and successful computations’ values in <a>Right</a>.
--   
--   <pre>
--   run (runResumable (pure a)) == Right @(SomeError Identity) @Int a
--   </pre>
runResumable :: (Carrier sig m, Effect sig) => Eff (ResumableC err m) a -> m (Either (SomeError err) a)
newtype ResumableC err m a
ResumableC :: m (Either (SomeError err) a) -> ResumableC err m a
[runResumableC] :: ResumableC err m a -> m (Either (SomeError err) a)

-- | Run a <a>Resumable</a> effect, resuming uncaught errors with a given
--   handler.
--   
--   Note that this may be less efficient than defining a specialized
--   carrier type and instance specifying the handler’s behaviour directly.
--   Performance-critical code may wish to do that to maximize the
--   opportunities for fusion and inlining.
--   
--   <pre>
--   &gt;&gt;&gt; data Err a where Err :: Int -&gt; Err Int
--   </pre>
--   
--   <pre>
--   run (runResumableWith (\ (Err b) -&gt; pure (1 + b)) (pure a)) == a
--   </pre>
--   
--   <pre>
--   run (runResumableWith (\ (Err b) -&gt; pure (1 + b)) (throwResumable (Err a))) == 1 + a
--   </pre>
runResumableWith :: (Carrier sig m, Monad m) => (forall x. err x -> m x) -> Eff (ResumableWithC err m) a -> m a
newtype ResumableWithC err m a
ResumableWithC :: ((forall x. err x -> m x) -> m a) -> ResumableWithC err m a
instance GHC.Base.Functor (Control.Effect.Resumable.Resumable err m)
instance (Control.Effect.Carrier.Carrier sig m, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Resumable.Resumable err Control.Effect.Sum.:+: sig) (Control.Effect.Resumable.ResumableWithC err m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig) => Control.Effect.Carrier.Carrier (Control.Effect.Resumable.Resumable err Control.Effect.Sum.:+: sig) (Control.Effect.Resumable.ResumableC err m)
instance Data.Functor.Classes.Eq1 err => GHC.Classes.Eq (Control.Effect.Resumable.SomeError err)
instance Data.Functor.Classes.Ord1 err => GHC.Classes.Ord (Control.Effect.Resumable.SomeError err)
instance Data.Functor.Classes.Show1 err => GHC.Show.Show (Control.Effect.Resumable.SomeError err)
instance Control.DeepSeq.NFData1 err => Control.DeepSeq.NFData (Control.Effect.Resumable.SomeError err)
instance Control.Effect.Carrier.HFunctor (Control.Effect.Resumable.Resumable err)
instance Control.Effect.Carrier.Effect (Control.Effect.Resumable.Resumable err)

module Control.Effect.Resource
data Resource m k
Resource :: m resource -> (resource -> m any) -> (resource -> m output) -> (output -> k) -> Resource m k

-- | Provides a safe idiom to acquire and release resources safely.
--   
--   When acquiring and operating on a resource (such as opening and
--   reading file handle with <tt>openFile</tt> or writing to a blob of
--   memory with <tt>malloc</tt>), any exception thrown during the
--   operation may mean that the resource is not properly released.
--   <tt>bracket acquire release op</tt> ensures that <tt>release</tt> is
--   run on the value returned from <tt>acquire</tt> even if <tt>op</tt>
--   throws an exception.
--   
--   <a>bracket</a> is safe in the presence of asynchronous exceptions.
bracket :: (Member Resource sig, Carrier sig m) => m resource -> (resource -> m any) -> (resource -> m a) -> m a
runResource :: (Carrier sig m, MonadIO m) => (forall x. m x -> IO x) -> Eff (ResourceC m) a -> m a
newtype ResourceC m a
ResourceC :: ((forall x. m x -> IO x) -> m a) -> ResourceC m a
instance GHC.Base.Functor (Control.Effect.Resource.Resource m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Monad.IO.Class.MonadIO m) => Control.Effect.Carrier.Carrier (Control.Effect.Resource.Resource Control.Effect.Sum.:+: sig) (Control.Effect.Resource.ResourceC m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Resource.Resource
instance Control.Effect.Carrier.Effect Control.Effect.Resource.Resource

module Control.Effect.Reader
data Reader r m k
Ask :: (r -> k) -> Reader r m k
Local :: (r -> r) -> m b -> (b -> k) -> Reader r m k

-- | Retrieve the environment value.
--   
--   <pre>
--   run (runReader a ask) == a
--   </pre>
ask :: (Member (Reader r) sig, Carrier sig m) => m r

-- | Project a function out of the current environment value.
--   
--   <pre>
--   snd (run (runReader a (asks (applyFun f)))) == applyFun f a
--   </pre>
asks :: (Member (Reader r) sig, Carrier sig m, Functor m) => (r -> a) -> m a

-- | Run a computation with an environment value locally modified by the
--   passed function.
--   
--   <pre>
--   run (runReader a (local (applyFun f) ask)) == applyFun f a
--   </pre>
--   
--   <pre>
--   run (runReader a ((,,) &lt;$&gt; ask &lt;*&gt; local (applyFun f) ask &lt;*&gt; ask)) == (a, applyFun f a, a)
--   </pre>
local :: (Member (Reader r) sig, Carrier sig m) => (r -> r) -> m a -> m a

-- | Run a <a>Reader</a> effect with the passed environment value.
--   
--   <pre>
--   run (runReader a (pure b)) == b
--   </pre>
runReader :: (Carrier sig m, Monad m) => r -> Eff (ReaderC r m) a -> m a
newtype ReaderC r m a
ReaderC :: (r -> m a) -> ReaderC r m a
[runReaderC] :: ReaderC r m a -> r -> m a
instance GHC.Base.Functor (Control.Effect.Reader.Reader r m)
instance (Control.Effect.Carrier.Carrier sig m, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Reader.Reader r Control.Effect.Sum.:+: sig) (Control.Effect.Reader.ReaderC r m)
instance Control.Effect.Carrier.HFunctor (Control.Effect.Reader.Reader r)
instance Control.Effect.Carrier.Effect (Control.Effect.Reader.Reader r)

module Control.Effect.Random
data Random m k
Random :: (a -> k) -> Random m k
RandomR :: (a, a) -> (a -> k) -> Random m k
Interleave :: m a -> (a -> k) -> Random m k

-- | Run a random computation starting from a given generator.
--   
--   <pre>
--   run (runRandom (PureGen a) (pure b)) == (PureGen a, b)
--   </pre>
runRandom :: (Carrier sig m, Effect sig, Monad m, RandomGen g) => g -> Eff (RandomC g m) a -> m (g, a)

-- | Run a random computation starting from a given generator and
--   discarding the final generator.
--   
--   <pre>
--   run (evalRandom (PureGen a) (pure b)) == b
--   </pre>
evalRandom :: (Carrier sig m, Effect sig, Monad m, RandomGen g) => g -> Eff (RandomC g m) a -> m a

-- | Run a random computation starting from a given generator and
--   discarding the final result.
--   
--   <pre>
--   run (execRandom (PureGen a) (pure b)) == PureGen a
--   </pre>
execRandom :: (Carrier sig m, Effect sig, Monad m, RandomGen g) => g -> Eff (RandomC g m) a -> m g

-- | Run a random computation in <a>IO</a>, splitting the global standard
--   generator to get a new one for the computation.
evalRandomIO :: (Carrier sig m, Effect sig, MonadIO m) => Eff (RandomC StdGen m) a -> m a
newtype RandomC g m a
RandomC :: (g -> m (g, a)) -> RandomC g m a
[runRandomC] :: RandomC g m a -> g -> m (g, a)

-- | With a source of random number supply in hand, the <a>MonadRandom</a>
--   class allows the programmer to extract random values of a variety of
--   types.
class Monad m => MonadRandom (m :: Type -> Type)

-- | Takes a range <i>(lo,hi)</i> and a random number generator <i>g</i>,
--   and returns a computation that returns a random value uniformly
--   distributed in the closed interval <i>[lo,hi]</i>, together with a new
--   generator. It is unspecified what happens if <i>lo&gt;hi</i>. For
--   continuous types there is no requirement that the values <i>lo</i> and
--   <i>hi</i> are ever produced, but they may be, depending on the
--   implementation and the interval.
--   
--   See <a>randomR</a> for details.
getRandomR :: (MonadRandom m, Random a) => (a, a) -> m a

-- | The same as <a>getRandomR</a>, but using a default range determined by
--   the type:
--   
--   <ul>
--   <li>For bounded types (instances of <a>Bounded</a>, such as
--   <a>Char</a>), the range is normally the whole type.</li>
--   <li>For fractional types, the range is normally the semi-closed
--   interval <tt>[0,1)</tt>.</li>
--   <li>For <a>Integer</a>, the range is (arbitrarily) the range of
--   <a>Int</a>.</li>
--   </ul>
--   
--   See <a>random</a> for details.
getRandom :: (MonadRandom m, Random a) => m a

-- | Plural variant of <a>getRandomR</a>, producing an infinite list of
--   random values instead of returning a new generator.
--   
--   See <a>randomRs</a> for details.
getRandomRs :: (MonadRandom m, Random a) => (a, a) -> m [a]

-- | Plural variant of <a>getRandom</a>, producing an infinite list of
--   random values instead of returning a new generator.
--   
--   See <a>randoms</a> for details.
getRandoms :: (MonadRandom m, Random a) => m [a]

-- | The class <a>MonadInterleave</a> proivides a convenient interface atop
--   a <a>split</a> operation on a random generator.
class MonadRandom m => MonadInterleave (m :: Type -> Type)

-- | If <tt>x :: m a</tt> is a computation in some random monad, then
--   <tt>interleave x</tt> works by splitting the generator, running
--   <tt>x</tt> using one half, and using the other half as the final
--   generator state of <tt>interleave x</tt> (replacing whatever the final
--   generator state otherwise would have been). This means that
--   computation needing random values which comes after <tt>interleave
--   x</tt> does not necessarily depend on the computation of <tt>x</tt>.
--   For example:
--   
--   <pre>
--   &gt;&gt;&gt; evalRandIO $ snd &lt;$&gt; ((,) &lt;$&gt; undefined &lt;*&gt; getRandom)
--   *** Exception: Prelude.undefined
--   &gt;&gt;&gt; evalRandIO $ snd &lt;$&gt; ((,) &lt;$&gt; interleave undefined &lt;*&gt; getRandom)
--   6192322188769041625
--   </pre>
--   
--   This can be used, for example, to allow random computations to run in
--   parallel, or to create lazy infinite structures of random values. In
--   the example below, the infinite tree <tt>randTree</tt> cannot be
--   evaluated lazily: even though it is cut off at two levels deep by
--   <tt>hew 2</tt>, the random value in the right subtree still depends on
--   generation of all the random values in the (infinite) left subtree,
--   even though they are ultimately unneeded. Inserting a call to
--   <tt>interleave</tt>, as in <tt>randTreeI</tt>, solves the problem: the
--   generator splits at each <tt>Node</tt>, so random values in the left
--   and right subtrees are generated independently.
--   
--   <pre>
--   data Tree = Leaf | Node Int Tree Tree deriving Show
--   
--   hew :: Int -&gt; Tree -&gt; Tree
--   hew 0 _    = Leaf
--   hew _ Leaf = Leaf
--   hew n (Node x l r) = Node x (hew (n-1) l) (hew (n-1) r)
--   
--   randTree :: Rand StdGen Tree
--   randTree = Node &lt;$&gt; getRandom &lt;*&gt; randTree &lt;*&gt; randTree
--   
--   randTreeI :: Rand StdGen Tree
--   randTreeI = interleave $ Node &lt;$&gt; getRandom &lt;*&gt; randTreeI &lt;*&gt; randTreeI
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; hew 2 &lt;$&gt; evalRandIO randTree
--   Node 2168685089479838995 (Node (-1040559818952481847) Leaf Leaf) (Node ^CInterrupted.
--   &gt;&gt;&gt; hew 2 &lt;$&gt; evalRandIO randTreeI
--   Node 8243316398511136358 (Node 4139784028141790719 Leaf Leaf) (Node 4473998613878251948 Leaf Leaf)
--   </pre>
interleave :: MonadInterleave m => m a -> m a
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, System.Random.RandomGen g, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Random.Internal.Random Control.Effect.Sum.:+: sig) (Control.Effect.Random.RandomC g m)

module Control.Effect.Lift
newtype Lift sig (m :: * -> *) k
Lift :: sig k -> Lift sig k
[unLift] :: Lift sig k -> sig k

-- | Extract a <a>Lift</a>ed <a>Monad</a>ic action from an effectful
--   computation.
runM :: Monad m => Eff (LiftC m) a -> m a
newtype LiftC m a
LiftC :: m a -> LiftC m a
[runLiftC] :: LiftC m a -> m a
instance GHC.Base.Monad m => Control.Effect.Carrier.Carrier (Control.Effect.Lift.Internal.Lift m) (Control.Effect.Lift.LiftC m)

module Control.Effect.Fresh
data Fresh m k
Fresh :: (Int -> k) -> Fresh m k
Reset :: m b -> (b -> k) -> Fresh m k

-- | Produce a fresh (i.e. unique) <a>Int</a>.
--   
--   <pre>
--   run (runFresh (replicateM n fresh)) == nub (run (runFresh (replicateM n fresh)))
--   </pre>
fresh :: (Member Fresh sig, Carrier sig m) => m Int

-- | Reset the fresh counter after running a computation.
--   
--   <pre>
--   run (runFresh (resetFresh (replicateM m fresh) *&gt; replicateM n fresh)) == run (runFresh (replicateM n fresh))
--   </pre>
resetFresh :: (Member Fresh sig, Carrier sig m) => m a -> m a

-- | Run a <a>Fresh</a> effect counting up from 0.
--   
--   <pre>
--   run (runFresh (replicateM n fresh)) == [0..pred n]
--   </pre>
--   
--   <pre>
--   run (runFresh (replicateM n fresh *&gt; pure b)) == b
--   </pre>
runFresh :: (Carrier sig m, Effect sig, Monad m) => Eff (FreshC m) a -> m a
newtype FreshC m a
FreshC :: (Int -> m (Int, a)) -> FreshC m a
[runFreshC] :: FreshC m a -> Int -> m (Int, a)
instance GHC.Base.Functor (Control.Effect.Fresh.Fresh m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Fresh.Fresh Control.Effect.Sum.:+: sig) (Control.Effect.Fresh.FreshC m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Fresh.Fresh
instance Control.Effect.Carrier.Effect Control.Effect.Fresh.Fresh

module Control.Effect.Fail
newtype Fail (m :: * -> *) k
Fail :: String -> Fail k

-- | When a value is bound in <tt>do</tt>-notation, the pattern on the left
--   hand side of <tt>&lt;-</tt> might not match. In this case, this class
--   provides a function to recover.
--   
--   A <a>Monad</a> without a <a>MonadFail</a> instance may only be used in
--   conjunction with pattern that always match, such as newtypes, tuples,
--   data types with only a single data constructor, and irrefutable
--   patterns (<tt>~pat</tt>).
--   
--   Instances of <a>MonadFail</a> should satisfy the following law:
--   <tt>fail s</tt> should be a left zero for <tt>&gt;&gt;=</tt>,
--   
--   <pre>
--   fail s &gt;&gt;= f  =  fail s
--   </pre>
--   
--   If your <a>Monad</a> is also <tt>MonadPlus</tt>, a popular definition
--   is
--   
--   <pre>
--   fail _ = mzero
--   </pre>
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a

-- | Run a <a>Fail</a> effect, returning failure messages in <a>Left</a>
--   and successful computations’ results in <a>Right</a>.
--   
--   <pre>
--   run (runFail (pure a)) == Right a
--   </pre>
runFail :: (Carrier sig m, Effect sig) => Eff (FailC m) a -> m (Either String a)
newtype FailC m a
FailC :: m (Either String a) -> FailC m a
[runFailC] :: FailC m a -> m (Either String a)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig) => Control.Effect.Carrier.Carrier (Control.Effect.Fail.Internal.Fail Control.Effect.Sum.:+: sig) (Control.Effect.Fail.FailC m)

module Control.Effect.Error
data Error exc m k
Throw :: exc -> Error exc m k
Catch :: m b -> (exc -> m b) -> (b -> k) -> Error exc m k

-- | Throw an error, escaping the current computation up to the nearest
--   <a>catchError</a> (if any).
--   
--   <pre>
--   run (runError (throwError a)) == Left @Int @Int a
--   </pre>
throwError :: (Member (Error exc) sig, Carrier sig m) => exc -> m a

-- | Run a computation which can throw errors with a handler to run on
--   error.
--   
--   Errors thrown by the handler will escape up to the nearest enclosing
--   <a>catchError</a> (if any).
--   
--   <pre>
--   run (runError (pure a `catchError` pure)) == Right a
--   </pre>
--   
--   <pre>
--   run (runError (throwError a `catchError` pure)) == Right @Int @Int a
--   </pre>
--   
--   <pre>
--   run (runError (throwError a `catchError` (throwError @Int))) == Left @Int @Int a
--   </pre>
catchError :: (Member (Error exc) sig, Carrier sig m) => m a -> (exc -> m a) -> m a

-- | Run an <a>Error</a> effect, returning uncaught errors in <a>Left</a>
--   and successful computations’ values in <a>Right</a>.
--   
--   <pre>
--   run (runError (pure a)) == Right @Int @Int a
--   </pre>
runError :: (Carrier sig m, Effect sig, Monad m) => Eff (ErrorC exc m) a -> m (Either exc a)
newtype ErrorC e m a
ErrorC :: m (Either e a) -> ErrorC e m a
[runErrorC] :: ErrorC e m a -> m (Either e a)
instance GHC.Base.Functor (Control.Effect.Error.Error exc m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Error.Error e Control.Effect.Sum.:+: sig) (Control.Effect.Error.ErrorC e m)
instance Control.Effect.Carrier.HFunctor (Control.Effect.Error.Error exc)
instance Control.Effect.Carrier.Effect (Control.Effect.Error.Error exc)

module Control.Effect.Cull

-- | <a>Cull</a> effects are used with <a>NonDet</a> to provide control
--   over branching.
data Cull m k
Cull :: m a -> (a -> k) -> Cull m k

-- | Cull nondeterminism in the argument, returning at most one result.
--   
--   <pre>
--   run (runNonDet (runCull (cull (pure a &lt;|&gt; pure b)))) == [a]
--   </pre>
--   
--   <pre>
--   run (runNonDet (runCull (cull (pure a &lt;|&gt; pure b) &lt;|&gt; pure c))) == [a, c]
--   </pre>
--   
--   <pre>
--   run (runNonDet (runCull (cull (asum (map pure (repeat a)))))) == [a]
--   </pre>
cull :: (Carrier sig m, Member Cull sig) => m a -> m a

-- | Run a <a>Cull</a> effect. Branches outside of any <a>cull</a> block
--   will not be pruned.
--   
--   <pre>
--   run (runNonDet (runCull (pure a &lt;|&gt; pure b))) == [a, b]
--   </pre>
runCull :: (Alternative m, Carrier sig m, Effect sig, Monad m) => Eff (CullC m) a -> m a
newtype CullC m a
CullC :: (Bool -> m (Branch m () a)) -> CullC m a
[runCullC] :: CullC m a -> Bool -> m (Branch m () a)
instance GHC.Base.Functor (Control.Effect.Cull.Cull m)
instance (GHC.Base.Alternative m, Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Cull.Cull Control.Effect.Sum.:+: (Control.Effect.NonDet.Internal.NonDet Control.Effect.Sum.:+: sig)) (Control.Effect.Cull.CullC m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Cull.Cull
instance Control.Effect.Carrier.Effect Control.Effect.Cull.Cull

module Control.Effect.NonDet
data NonDet (m :: * -> *) k
Empty :: NonDet k
Choose :: (Bool -> k) -> NonDet k

-- | A monoid on applicative functors.
--   
--   If defined, <a>some</a> and <a>many</a> should be the least solutions
--   of the equations:
--   
--   <ul>
--   <li><pre><a>some</a> v = (:) <tt>&lt;$&gt;</tt> v <a>&lt;*&gt;</a>
--   <a>many</a> v</pre></li>
--   <li><pre><a>many</a> v = <a>some</a> v <a>&lt;|&gt;</a> <a>pure</a>
--   []</pre></li>
--   </ul>
class Applicative f => Alternative (f :: Type -> Type)

-- | The identity of <a>&lt;|&gt;</a>
empty :: Alternative f => f a

-- | An associative binary operation
(<|>) :: Alternative f => f a -> f a -> f a

-- | One or more.
some :: Alternative f => f a -> f [a]

-- | Zero or more.
many :: Alternative f => f a -> f [a]
infixl 3 <|>

-- | Run a <a>NonDet</a> effect, collecting all branches’ results into an
--   <a>Alternative</a> functor.
--   
--   Using '[]' as the <a>Alternative</a> functor will produce all results,
--   while <a>Maybe</a> will return only the first. However, unlike
--   <a>runNonDetOnce</a>, this will still enumerate the entire search
--   space before returning, meaning that it will diverge for infinite
--   search spaces, even when using <a>Maybe</a>.
--   
--   <pre>
--   run (runNonDet (pure a)) == [a]
--   </pre>
--   
--   <pre>
--   run (runNonDet (pure a)) == Just a
--   </pre>
runNonDet :: (Alternative f, Monad f, Traversable f, Carrier sig m, Effect sig, Applicative m) => Eff (AltC f m) a -> m (f a)
newtype AltC f m a
AltC :: m (f a) -> AltC f m a
[runAltC] :: AltC f m a -> m (f a)

-- | Run a <a>NonDet</a> effect, returning the first successful result in
--   an <a>Alternative</a> functor.
--   
--   Unlike <a>runNonDet</a>, this will terminate immediately upon finding
--   a solution.
--   
--   <pre>
--   run (runNonDetOnce (asum (map pure (repeat a)))) == [a]
--   </pre>
--   
--   <pre>
--   run (runNonDetOnce (asum (map pure (repeat a)))) == Just a
--   </pre>
runNonDetOnce :: (Alternative f, Monad f, Traversable f, Carrier sig m, Effect sig, Monad m) => Eff (OnceC f m) a -> m (f a)
newtype OnceC f m a
OnceC :: Eff (CullC (Eff (AltC f m))) a -> OnceC f m a
[runOnceC] :: OnceC f m a -> Eff (CullC (Eff (AltC f m))) a

-- | The result of a nondeterministic branch of a computation.
--   
--   <a>Branch</a> can be used to define <a>NonDet</a> carriers which
--   control nondeterminism in some specific way, e.g. pruning branches
--   according to some specific heuristic.
data Branch m e a
None :: e -> Branch m e a
Pure :: a -> Branch m e a
Alt :: m a -> m a -> Branch m e a

-- | Case analysis for <a>Branch</a>, taking a value to use for
--   <tt>Cut</tt>, a value to use for <a>None</a>, and a function to apply
--   to the contents of <a>Pure</a>.
--   
--   <pre>
--   branch None Pure Alt a == (a :: Branch e [] a)
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (None a :: Branch [] a) == applyFun f a
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (Pure a :: Branch [] a) == applyFun g a
--   </pre>
--   
--   <pre>
--   branch (applyFun f) (applyFun g) (applyFun2 h) (Alt a b :: Branch [] a) == applyFun2 h a b
--   </pre>
branch :: (e -> a) -> (b -> a) -> (m b -> m b -> a) -> Branch m e b -> a

-- | Interpret a <a>Branch</a> into an underlying <a>Alternative</a>
--   context.
runBranch :: Alternative m => (e -> m a) -> Branch m e a -> m a
instance (GHC.Base.Alternative f, Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, Data.Traversable.Traversable f, GHC.Base.Monad f, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.NonDet.Internal.NonDet Control.Effect.Sum.:+: sig) (Control.Effect.NonDet.OnceC f m)
instance (GHC.Base.Alternative f, GHC.Base.Monad f, Data.Traversable.Traversable f, Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Applicative m) => Control.Effect.Carrier.Carrier (Control.Effect.NonDet.Internal.NonDet Control.Effect.Sum.:+: sig) (Control.Effect.NonDet.AltC f m)

module Control.Effect.Cut

-- | <a>Cut</a> effects are used with <a>NonDet</a> to provide control over
--   backtracking.
data Cut m k
Cutfail :: Cut m k
Call :: m a -> (a -> k) -> Cut m k

-- | Fail the current branch, and prevent backtracking within the nearest
--   enclosing <a>call</a> (if any).
--   
--   Contrast with <a>empty</a>, which fails the current branch but allows
--   backtracking.
--   
--   <pre>
--   run (runNonDet (runCut (cutfail &lt;|&gt; pure a))) == []
--   </pre>
--   
--   <pre>
--   run (runNonDet (runCut (pure a &lt;|&gt; cutfail))) == [a]
--   </pre>
cutfail :: (Carrier sig m, Member Cut sig) => m a

-- | Delimit the effect of <a>cutfail</a>s, allowing backtracking to
--   resume.
--   
--   <pre>
--   run (runNonDet (runCut (call (cutfail &lt;|&gt; pure a) &lt;|&gt; pure b))) == [b]
--   </pre>
call :: (Carrier sig m, Member Cut sig) => m a -> m a

-- | Commit to the current branch, preventing backtracking within the
--   nearest enclosing <a>call</a> (if any) on failure.
--   
--   <pre>
--   run (runNonDet (runCut (pure a &lt;|&gt; cut *&gt; pure b))) == [a, b]
--   </pre>
--   
--   <pre>
--   run (runNonDet (runCut (cut *&gt; pure a &lt;|&gt; pure b))) == [a]
--   </pre>
--   
--   <pre>
--   run (runNonDet (runCut (cut *&gt; empty &lt;|&gt; pure a))) == []
--   </pre>
cut :: (Alternative m, Carrier sig m, Member Cut sig) => m ()

-- | Run a <a>Cut</a> effect within an underlying <a>Alternative</a>
--   instance (typically <a>Eff</a> carrying a <a>NonDet</a> effect).
--   
--   <pre>
--   run (runNonDetOnce (runCut (pure a))) == Just a
--   </pre>
runCut :: (Alternative m, Carrier sig m, Effect sig, Monad m) => Eff (CutC m) a -> m a
newtype CutC m a
CutC :: m (Branch m Bool a) -> CutC m a
[runCutC] :: CutC m a -> m (Branch m Bool a)
instance GHC.Base.Functor (Control.Effect.Cut.Cut m)
instance (GHC.Base.Alternative m, Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Monad m) => Control.Effect.Carrier.Carrier (Control.Effect.Cut.Cut Control.Effect.Sum.:+: (Control.Effect.NonDet.Internal.NonDet Control.Effect.Sum.:+: sig)) (Control.Effect.Cut.CutC m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Cut.Cut
instance Control.Effect.Carrier.Effect Control.Effect.Cut.Cut

module Control.Effect.Trace
data Trace (m :: * -> *) k
Trace :: String -> k -> Trace k
[traceMessage] :: Trace k -> String
[traceCont] :: Trace k -> k

-- | Append a message to the trace log.
trace :: (Member Trace sig, Carrier sig m) => String -> m ()

-- | Run a <a>Trace</a> effect, printing traces to <a>stderr</a>.
runTraceByPrinting :: (MonadIO m, Carrier sig m) => Eff (TraceByPrintingC m) a -> m a
newtype TraceByPrintingC m a
TraceByPrintingC :: m a -> TraceByPrintingC m a
[runTraceByPrintingC] :: TraceByPrintingC m a -> m a

-- | Run a <a>Trace</a> effect, ignoring all traces.
--   
--   <pre>
--   run (runTraceByIgnoring (trace a *&gt; pure b)) == b
--   </pre>
runTraceByIgnoring :: Carrier sig m => Eff (TraceByIgnoringC m) a -> m a
newtype TraceByIgnoringC m a
TraceByIgnoringC :: m a -> TraceByIgnoringC m a
[runTraceByIgnoringC] :: TraceByIgnoringC m a -> m a

-- | Run a <a>Trace</a> effect, returning all traces as a list.
--   
--   <pre>
--   run (runTraceByReturning (trace a *&gt; trace b *&gt; pure c)) == ([a, b], c)
--   </pre>
runTraceByReturning :: (Carrier sig m, Effect sig, Functor m) => Eff (TraceByReturningC m) a -> m ([String], a)
newtype TraceByReturningC m a
TraceByReturningC :: ([String] -> m ([String], a)) -> TraceByReturningC m a
[runTraceByReturningC] :: TraceByReturningC m a -> [String] -> m ([String], a)
instance GHC.Base.Functor (Control.Effect.Trace.Trace m)
instance (Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig) => Control.Effect.Carrier.Carrier (Control.Effect.Trace.Trace Control.Effect.Sum.:+: sig) (Control.Effect.Trace.TraceByReturningC m)
instance Control.Effect.Carrier.Carrier sig m => Control.Effect.Carrier.Carrier (Control.Effect.Trace.Trace Control.Effect.Sum.:+: sig) (Control.Effect.Trace.TraceByIgnoringC m)
instance (Control.Monad.IO.Class.MonadIO m, Control.Effect.Carrier.Carrier sig m) => Control.Effect.Carrier.Carrier (Control.Effect.Trace.Trace Control.Effect.Sum.:+: sig) (Control.Effect.Trace.TraceByPrintingC m)
instance Control.Effect.Carrier.HFunctor Control.Effect.Trace.Trace
instance Control.Effect.Carrier.Effect Control.Effect.Trace.Trace

module Control.Effect.Void
data Void (m :: * -> *) k

-- | Run an <a>Eff</a> exhausted of effects to produce its final result
--   value.
run :: Eff VoidC a -> a
newtype VoidC a
VoidC :: a -> VoidC a
[runVoidC] :: VoidC a -> a
instance GHC.Base.Functor (Control.Effect.Void.Void m)
instance Control.Effect.Carrier.Carrier Control.Effect.Void.Void Control.Effect.Void.VoidC
instance Control.Effect.Carrier.HFunctor Control.Effect.Void.Void
instance Control.Effect.Carrier.Effect Control.Effect.Void.Void

module Control.Effect.Writer
data Writer w (m :: * -> *) k
Tell :: w -> k -> Writer w k

-- | Write a value to the log.
--   
--   <pre>
--   fst (run (runWriter (mapM_ (tell . Sum) (0 : ws)))) == foldMap Sum ws
--   </pre>
tell :: (Member (Writer w) sig, Carrier sig m) => w -> m ()

-- | Run a <a>Writer</a> effect with a <a>Monoid</a>al log, producing the
--   final log alongside the result value.
--   
--   <pre>
--   run (runWriter (tell (Sum a) *&gt; pure b)) == (Sum a, b)
--   </pre>
runWriter :: (Carrier sig m, Effect sig, Functor m, Monoid w) => Eff (WriterC w m) a -> m (w, a)

-- | Run a <a>Writer</a> effect with a <a>Monoid</a>al log, producing the
--   final log and discarding the result value.
--   
--   <pre>
--   run (execWriter (tell (Sum a) *&gt; pure b)) == Sum a
--   </pre>
execWriter :: (Carrier sig m, Effect sig, Functor m, Monoid w) => Eff (WriterC w m) a -> m w
newtype WriterC w m a
WriterC :: m (w, a) -> WriterC w m a
[runWriterC] :: WriterC w m a -> m (w, a)
instance GHC.Base.Functor (Control.Effect.Writer.Writer w m)
instance (GHC.Base.Monoid w, Control.Effect.Carrier.Carrier sig m, Control.Effect.Carrier.Effect sig, GHC.Base.Functor m) => Control.Effect.Carrier.Carrier (Control.Effect.Writer.Writer w Control.Effect.Sum.:+: sig) (Control.Effect.Writer.WriterC w m)
instance Control.Effect.Carrier.HFunctor (Control.Effect.Writer.Writer w)
instance Control.Effect.Carrier.Effect (Control.Effect.Writer.Writer w)

module Control.Effect

-- | The class of carriers (results) for algebras (effect handlers) over
--   signatures (effects), whose actions are given by the <a>ret</a> and
--   <a>eff</a> methods.
class HFunctor sig => Carrier sig h | h -> sig

-- | The class of effect types, which must:
--   
--   <ol>
--   <li>Be functorial in their last two arguments, and</li>
--   <li>Support threading effects in higher-order positions through using
--   the carrier’s suspended state.</li>
--   </ol>
class HFunctor sig => Effect sig
data Fail (m :: * -> *) k
data Lift sig (m :: * -> *) k
data NonDet (m :: * -> *) k
data Random m k
class Member (sub :: (* -> *) -> (* -> *)) sup
data ( f :+: g ) (m :: * -> *) k
infixr 4 :+:

-- | Construct a request for an effect to be interpreted by some handler
--   later on.
send :: (Member effect sig, Carrier sig m) => effect m (m a) -> m a
data Eff carrier a
interpret :: Carrier sig carrier => Eff carrier a -> carrier a
data StateC s m a
data State s (m :: * -> *) k
data ResumableWithC err m a
data ResumableC err m a

-- | Errors which can be resumed with values of some
--   existentially-quantified type.
data Resumable err (m :: * -> *) k
data ResourceC m a
data Resource m k
data ReaderC r m a
data Reader r m k
data RandomC g m a
data LiftC m a

-- | Extract a <a>Lift</a>ed <a>Monad</a>ic action from an effectful
--   computation.
runM :: Monad m => Eff (LiftC m) a -> m a
data FreshC m a
data Fresh m k
data FailC m a
data ErrorC e m a
data Error exc m k
data CullC m a

-- | <a>Cull</a> effects are used with <a>NonDet</a> to provide control
--   over branching.
data Cull m k
data OnceC f m a
data AltC f m a
data CutC m a

-- | <a>Cut</a> effects are used with <a>NonDet</a> to provide control over
--   backtracking.
data Cut m k
data TraceByReturningC m a
data TraceByIgnoringC m a
data TraceByPrintingC m a
data Trace (m :: * -> *) k
data VoidC a
data Void (m :: * -> *) k

-- | Run an <a>Eff</a> exhausted of effects to produce its final result
--   value.
run :: Eff VoidC a -> a
data WriterC w m a
data Writer w (m :: * -> *) k
