Safe Haskell	None
Language	Haskell2010

Control.Effect.Exceptional

Contents

Effects
Actions
Interpretations
Simple variants of interpretations
Threading constraints
MonadCatch
Carriers

Synopsis

data Exceptional eff exc m a
type SafeError exc = Exceptional (Throw exc) exc
catching :: forall eff exc m a. Eff (Exceptional eff exc) m => ExceptionallyC eff exc m a -> (exc -> m a) -> m a
trying :: forall eff exc m a. Eff (Exceptional eff exc) m => ExceptionallyC eff exc m a -> m (Either exc a)
throwing :: forall eff exc m a. Effs [Exceptional eff exc, Throw exc] m => ExceptionallyC eff exc m a -> m a
catchSafe :: forall exc m a. Eff (SafeError exc) m => ExceptionallyC (Throw exc) exc m a -> (exc -> m a) -> m a
trySafe :: forall exc m a. Eff (SafeError exc) m => ExceptionallyC (Throw exc) exc m a -> m (Either exc a)
runExceptional :: forall eff exc m a. (Member eff (Derivs m), Eff (Catch exc) m) => ExceptionalC eff exc m a -> m a
runExceptionalJust :: forall eff smallExc bigExc m a. (Member eff (Derivs m), Eff (Error bigExc) m) => (bigExc -> Maybe smallExc) -> InterpretReifiedC (Exceptional eff smallExc) m a -> m a
safeErrorToError :: forall exc m a. Eff (Error exc) m => SafeErrorToErrorC exc m a -> m a
runSafeError :: forall e m a p. (Carrier m, Threaders '[ErrorThreads] m p) => SafeErrorC e m a -> m a
safeErrorToIO :: forall e m a. (Eff (Embed IO) m, MonadCatch m) => SafeErrorToIOC e m a -> m a
safeErrorToErrorIO :: forall e m a. Effs '[Embed IO, ErrorIO] m => SafeErrorToErrorIOC e m a -> m a
runExceptionalJustSimple :: forall eff smallExc bigExc m a p. (Member eff (Derivs m), Eff (Error bigExc) m, Threaders '[ReaderThreads] m p) => (bigExc -> Maybe smallExc) -> InterpretSimpleC (Exceptional eff smallExc) m a -> m a
safeErrorToIOSimple :: forall e m a p. (Eff (Embed IO) m, MonadCatch m, Threaders '[ReaderThreads] m p) => SafeErrorToIOSimpleC e m a -> m a
safeErrorToErrorIOSimple :: forall e m a p. (Effs '[ErrorIO, Embed IO] m, Threaders '[ReaderThreads] m p) => SafeErrorToErrorIOSimpleC e m a -> m a
class (forall e. Threads (ExceptT e) p) => ErrorThreads p
class MonadThrow m => MonadCatch (m :: Type -> Type)
data ExceptionallyC (eff :: Effect) (exc :: *) m a
type ExceptionalC eff exc = InterpretC ExceptionalH (Exceptional eff exc)
type SafeErrorToErrorC exc = ExceptionalC (Throw exc) exc
data SafeErrorC exc m a
data SafeErrorToIOC' s s' exc m a
type SafeErrorToIOC e m a = forall s s'. ReifiesErrorHandler s s' e (ErrorIOToIOC m) => SafeErrorToIOC' s s' e m a
data SafeErrorToErrorIOC' s s' exc m a
type SafeErrorToErrorIOC e m a = forall s s'. ReifiesErrorHandler s s' e m => SafeErrorToErrorIOC' s s' e m a
data SafeErrorToIOSimpleC exc m a
data SafeErrorToErrorIOSimpleC exc m a

Effects

data Exceptional eff exc m a Source #

An effect that allows for the safe use of an effect eff that may throw exceptions of the type exc by forcing the user to eventually catch those exceptions at some point of the program.

The main combinator of Exceptional is catching.

This could be unsafe in the presence of Conc. If you use catching on a computation that:

Spawns an asynchronous computation
Throws an exception inside the asynchronous computation from a use of eff
Returns the Async of that asynchronous computation

Then waiting on that Async outside of the catching will throw that exception without it being caught.

Instances

Instances details

(Member eff (Derivs m), Eff (Catch exc) m) => Handler ExceptionalH (Exceptional eff exc) m Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods effHandler :: EffHandler (Exceptional eff exc) m Source #

type SafeError exc = Exceptional (Throw exc) exc Source #

A particularly useful specialization of Exceptional, for gaining restricted access to an Error exc effect. Main combinators are catchSafe and trySafe.

Actions

catching :: forall eff exc m a. Eff (Exceptional eff exc) m => ExceptionallyC eff exc m a -> (exc -> m a) -> m a Source #

Gain access to eff and Catch exc within a region, but only if you're ready to handle any unhandled exception e :: exc that may arise from the use of eff within that region.

For example:

-- A part of the program unknowing and uncaring that the use of SomeEffect
-- may throw exceptions.
uncaringProgram :: Eff SomeEffect m => m String
uncaringProgram = do
  doSomeThing
  doSomeOtherThing

caringProgram :: Eff (Exceptional SomeEffect SomeEffectExc) m => m String
caringProgram =
  catching @SomeEffect uncaringProgram (\(exc :: SomeEffectExc) -> handlerForSomeEffectExc exc)

It's possible the Catch exc effect catching gives you access to would override another, identical Catch exc effect that you want to use inside the region. To avoid this, use catching together with intro1:

catching @SomeEffect (intro1 uncaringProgram) ...

If you do this, then catching will only introduce eff to be used in uncaringProgram, and not Catch exc.

trying :: forall eff exc m a. Eff (Exceptional eff exc) m => ExceptionallyC eff exc m a -> m (Either exc a) Source #

Gain access to eff and Catch exc within a region. If any use of eff within that region throws an unhandled exception e :: exc, then this returns Left e.

throwing :: forall eff exc m a. Effs [Exceptional eff exc, Throw exc] m => ExceptionallyC eff exc m a -> m a Source #

Gain access to eff and Catch exc within a region, rethrowing any exception e :: exc that may occur from the use of eff within that region.

catchSafe :: forall exc m a. Eff (SafeError exc) m => ExceptionallyC (Throw exc) exc m a -> (exc -> m a) -> m a Source #

Gain access to Error exc within a region, but only if you're ready to handle any unhandled exception e :: exc that may arise from within that region.

trySafe :: forall exc m a. Eff (SafeError exc) m => ExceptionallyC (Throw exc) exc m a -> m (Either exc a) Source #

Gain access to Error exc within a region. If any unhandled exception e :: exc is thrown within that region, then this returns Left e.

Interpretations

runExceptional :: forall eff exc m a. (Member eff (Derivs m), Eff (Catch exc) m) => ExceptionalC eff exc m a -> m a Source #

Run an Exceptional eff exc effect if both eff and Catch exc are part of the effect stack.

In order for this to be safe, you must ensure that the Catch exc catches all exceptions that arise from the use of eff and that only uses of eff throws those exceptions. Otherwise, the use of catching is liable to catch exceptions not arising from uses of eff, or fail to catch exceptions that do arise from uses of eff.

runExceptionalJust :: forall eff smallExc bigExc m a. (Member eff (Derivs m), Eff (Error bigExc) m) => (bigExc -> Maybe smallExc) -> InterpretReifiedC (Exceptional eff smallExc) m a -> m a Source #

Run an Exceptional eff exc effect if eff is part of the effect stack, provided a function that identifies the kind of exceptions that may arise from the use of eff.

In order for this to be safe, you must ensure that the function identifies all exceptions that arise from the use of eff and that only uses of eff throws those exceptions. Otherwise, the use of catching is liable to catch other exceptions not arising from uses of eff, or fail to catch exceptions that do arise from uses of eff.

The type of this interpreter is higher-rank, as it makes use of InterpretReifiedC. This makes runExceptionalJust difficult to use partially applied; for example, you can't compose it using .. You may prefer the simpler, but less performant, runExceptionalJustSimple.

safeErrorToError :: forall exc m a. Eff (Error exc) m => SafeErrorToErrorC exc m a -> m a Source #

Run a SafeError exc effect by transforming it into an Error exc effect.

runSafeError :: forall e m a p. (Carrier m, Threaders '[ErrorThreads] m p) => SafeErrorC e m a -> m a Source #

Run a SafeError e effect purely.

Derivs (SafeErrorC e m) = SafeError e ': Prims m

Prims (SafeErrorC e m) = Optional ((->) e) ': Prims m

safeErrorToIO :: forall e m a. (Eff (Embed IO) m, MonadCatch m) => SafeErrorToIOC e m a -> m a Source #

Runs a SafeError e effect by making use of IO exceptions.

Derivs (SafeErrorToIOC e m) = SafeError e ': Derivs m

Prims (SafeErrorToIOC e m) = Optional ((->) SomeException) ': Prims m

This has a higher-rank type, as it makes use of SafeErrorToIOC. This makes safeErrorToIO very difficult to use partially applied. In particular, it can't be composed using ..

If performance is secondary, consider using the slower safeErrorToIOSimple, which doesn't have a higher-rank type.

safeErrorToErrorIO :: forall e m a. Effs '[Embed IO, ErrorIO] m => SafeErrorToErrorIOC e m a -> m a Source #

Runs a SafeError e effect by transforming it into ErrorIO and Embed IO.

This has a higher-rank type, as it makes use of SafeErrorToErrorIOC. This makes safeErrorToErrorIO very difficult to use partially applied. In particular, it can't be composed using ..

If performance is secondary, consider using the slower safeErrorToErrorIOSimple, which doesn't have a higher-rank type.

Simple variants of interpretations

runExceptionalJustSimple :: forall eff smallExc bigExc m a p. (Member eff (Derivs m), Eff (Error bigExc) m, Threaders '[ReaderThreads] m p) => (bigExc -> Maybe smallExc) -> InterpretSimpleC (Exceptional eff smallExc) m a -> m a Source #

Run an Exceptional eff exc effect if eff is part of the effect stack, provided a function that identifies the kind of exceptions that may arise from the use of eff.

In order for this to be safe, you must ensure that the function identifies all exceptions that arise from the use of eff and that only uses of eff throws those exceptions. Otherwise, the use of catching is liable to catch exceptions not arising from uses of eff, or fail to catch exceptions that do arise from uses of eff.

This is a less performant version of runExceptionalJust, but doesn't have a higher-rank type. This makes runExceptionalJustSimple much easier to use partially applied.

safeErrorToIOSimple :: forall e m a p. (Eff (Embed IO) m, MonadCatch m, Threaders '[ReaderThreads] m p) => SafeErrorToIOSimpleC e m a -> m a Source #

Runs a SafeError e effect by making use of IO exceptions.

Derivs (SafeErrorToIOSimpleC e m) = SafeError e ': Derivs m

Prims (SafeErrorToIOSimpleC e m) = Optional ((->) SomeException) ': Prims m

This is a less performant version of safeErrorToIO that doesn't have a higher-rank type, making it much easier to use partially applied.

safeErrorToErrorIOSimple :: forall e m a p. (Effs '[ErrorIO, Embed IO] m, Threaders '[ReaderThreads] m p) => SafeErrorToErrorIOSimpleC e m a -> m a Source #

Runs a SafeError e effect by transforming it into ErrorIO and Embed IO.

This is a less performant version of safeErrorToErrorIO that doesn't have a higher-rank type, making it much easier to use partially applied.

Threading constraints

class (forall e. Threads (ExceptT e) p) => ErrorThreads p Source #

ErrorThreads accepts the following primitive effects:

Regional s
Optional s (when s is a functor)
BaseControl b
Unravel p
ListenPrim o (when o is a Monoid)
WriterPrim o (when o is a Monoid)
ReaderPrim i
Mask
Bracket
Fix

Instances

Instances details

(forall e. Threads (ExceptT e) p) => ErrorThreads p Source #
Instance details Defined in Control.Effect.Internal.Error

MonadCatch

class MonadThrow m => MonadCatch (m :: Type -> Type) #

A class for monads which allow exceptions to be caught, in particular exceptions which were thrown by throwM.

Instances should obey the following law:

catch (throwM e) f = f e

Note that the ability to catch an exception does not guarantee that we can deal with all possible exit points from a computation. Some monads, such as continuation-based stacks, allow for more than just a success/failure strategy, and therefore catch cannot be used by those monads to properly implement a function such as finally. For more information, see MonadMask.

Minimal complete definition

catch

Instances

Instances details

MonadCatch IO
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IO a -> (e -> IO a) -> IO a #
MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => STM a -> (e -> STM a) -> STM a #
e ~ SomeException => MonadCatch (Either e)	Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => Either e a -> (e0 -> Either e a) -> Either e a #
MonadCatch m => MonadCatch (MaybeT m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadCatch m => MonadCatch (ListT m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => ListT m a -> (e -> ListT m a) -> ListT m a #
MonadCatch m => MonadCatch (ErrorIOToIOC m) Source #
Instance details Defined in Control.Effect.Internal.ErrorIO Methods catch :: Exception e => ErrorIOToIOC m a -> (e -> ErrorIOToIOC m a) -> ErrorIOToIOC m a #
MonadCatch m => MonadCatch (ConcToIOC m) Source #
Instance details Defined in Control.Effect.Internal.Conc Methods catch :: Exception e => ConcToIOC m a -> (e -> ConcToIOC m a) -> ConcToIOC m a #
MonadCatch m => MonadCatch (TraceListC m) Source #
Instance details Defined in Control.Effect.Trace Methods catch :: Exception e => TraceListC m a -> (e -> TraceListC m a) -> TraceListC m a #
MonadCatch m => MonadCatch (ListT m) Source #
Instance details Defined in Control.Monad.Trans.List.Church Methods catch :: Exception e => ListT m a -> (e -> ListT m a) -> ListT m a #
MonadCatch m => MonadCatch (NonDetC m) Source #
Instance details Defined in Control.Effect.Internal.NonDet Methods catch :: Exception e => NonDetC m a -> (e -> NonDetC m a) -> NonDetC m a #
MonadCatch m => MonadCatch (CullCutC m) Source #
Instance details Defined in Control.Effect.Internal.NonDet Methods catch :: Exception e => CullCutC m a -> (e -> CullCutC m a) -> CullCutC m a #
MonadCatch m => MonadCatch (LogicC m) Source #
Instance details Defined in Control.Effect.Internal.NonDet Methods catch :: Exception e => LogicC m a -> (e -> LogicC m a) -> LogicC m a #
MonadCatch m => MonadCatch (InterpretFailSimpleC m) Source #
Instance details Defined in Control.Effect.Fail Methods catch :: Exception e => InterpretFailSimpleC m a -> (e -> InterpretFailSimpleC m a) -> InterpretFailSimpleC m a #
MonadCatch m => MonadCatch (FailC m) Source #
Instance details Defined in Control.Effect.Fail Methods catch :: Exception e => FailC m a -> (e -> FailC m a) -> FailC m a #
MonadCatch m => MonadCatch (AltMaybeC m) Source #
Instance details Defined in Control.Effect.Alt Methods catch :: Exception e => AltMaybeC m a -> (e -> AltMaybeC m a) -> AltMaybeC m a #
MonadCatch m => MonadCatch (InterpretAltSimpleC m) Source #
Instance details Defined in Control.Effect.Alt Methods catch :: Exception e => InterpretAltSimpleC m a -> (e -> InterpretAltSimpleC m a) -> InterpretAltSimpleC m a #
MonadCatch m => MonadCatch (ExceptT e m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadCatch m => MonadCatch (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
(Error e, MonadCatch m) => MonadCatch (ErrorT e m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => ErrorT e m a -> (e0 -> ErrorT e m a) -> ErrorT e m a #
MonadCatch m => MonadCatch (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
MonadCatch (CompositionBaseT ts m) => MonadCatch (CompositionC ts m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Compose Methods catch :: Exception e => CompositionC ts m a -> (e -> CompositionC ts m a) -> CompositionC ts m a #
Eff ErrorIO m => MonadCatch (Effly m) Source #
Instance details Defined in Control.Effect.Internal.Effly Methods catch :: Exception e => Effly m a -> (e -> Effly m a) -> Effly m a #
MonadCatch m => MonadCatch (InterpretPrimSimpleC e m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => InterpretPrimSimpleC e m a -> (e0 -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a #
MonadCatch m => MonadCatch (InterpretSimpleC e m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => InterpretSimpleC e m a -> (e0 -> InterpretSimpleC e m a) -> InterpretSimpleC e m a #
MonadCatch m => MonadCatch (EmbedC m) Source #
Instance details Defined in Control.Effect.Embed Methods catch :: Exception e => EmbedC m a -> (e -> EmbedC m a) -> EmbedC m a #
MonadCatch m => MonadCatch (RunMC m) Source #
Instance details Defined in Control.Effect.Embed Methods catch :: Exception e => RunMC m a -> (e -> RunMC m a) -> RunMC m a #
(Monoid o, MonadCatch m) => MonadCatch (WriterLazyC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => WriterLazyC o m a -> (e -> WriterLazyC o m a) -> WriterLazyC o m a #
(Monoid o, MonadCatch m) => MonadCatch (ListenLazyC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => ListenLazyC o m a -> (e -> ListenLazyC o m a) -> ListenLazyC o m a #
(Monoid o, MonadCatch m) => MonadCatch (TellLazyC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => TellLazyC o m a -> (e -> TellLazyC o m a) -> TellLazyC o m a #
(Monoid o, MonadCatch m) => MonadCatch (WriterC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => WriterC o m a -> (e -> WriterC o m a) -> WriterC o m a #
(Monoid o, MonadCatch m) => MonadCatch (ListenC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => ListenC o m a -> (e -> ListenC o m a) -> ListenC o m a #
(Monoid o, MonadCatch m) => MonadCatch (TellC o m) Source #
Instance details Defined in Control.Effect.Internal.Writer Methods catch :: Exception e => TellC o m a -> (e -> TellC o m a) -> TellC o m a #
MonadCatch m => MonadCatch (UnliftC m) Source #
Instance details Defined in Control.Effect.Internal.Unlift Methods catch :: Exception e => UnliftC m a -> (e -> UnliftC m a) -> UnliftC m a #
MonadCatch m => MonadCatch (StateLazyC s m) Source #
Instance details Defined in Control.Effect.Internal.State Methods catch :: Exception e => StateLazyC s m a -> (e -> StateLazyC s m a) -> StateLazyC s m a #
MonadCatch m => MonadCatch (StateC s m) Source #
Instance details Defined in Control.Effect.Internal.State Methods catch :: Exception e => StateC s m a -> (e -> StateC s m a) -> StateC s m a #
MonadCatch m => MonadCatch (HoistC m) Source #
Instance details Defined in Control.Effect.Internal.Regional Methods catch :: Exception e => HoistC m a -> (e -> HoistC m a) -> HoistC m a #
MonadCatch m => MonadCatch (ReaderC i m) Source #
Instance details Defined in Control.Effect.Internal.Reader Methods catch :: Exception e => ReaderC i m a -> (e -> ReaderC i m a) -> ReaderC i m a #
MonadCatch m => MonadCatch (HoistOptionC m) Source #
Instance details Defined in Control.Effect.Internal.Optional Methods catch :: Exception e => HoistOptionC m a -> (e -> HoistOptionC m a) -> HoistOptionC m a #
MonadCatch m => MonadCatch (UnwrapTopC e m) Source #
Instance details Defined in Control.Effect.Internal.Newtype Methods catch :: Exception e0 => UnwrapTopC e m a -> (e0 -> UnwrapTopC e m a) -> UnwrapTopC e m a #
MonadCatch m => MonadCatch (UnwrapC e m) Source #
Instance details Defined in Control.Effect.Internal.Newtype Methods catch :: Exception e0 => UnwrapC e m a -> (e0 -> UnwrapC e m a) -> UnwrapC e m a #
MonadCatch m => MonadCatch (ErrorToIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ErrorToIOSimpleC e m a -> (e0 -> ErrorToIOSimpleC e m a) -> ErrorToIOSimpleC e m a #
MonadCatch m => MonadCatch (InterpretErrorSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => InterpretErrorSimpleC e m a -> (e0 -> InterpretErrorSimpleC e m a) -> InterpretErrorSimpleC e m a #
MonadCatch m => MonadCatch (ErrorToIOAsExcC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ErrorToIOAsExcC e m a -> (e0 -> ErrorToIOAsExcC e m a) -> ErrorToIOAsExcC e m a #
MonadCatch m => MonadCatch (ErrorToErrorIOAsExcC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ErrorToErrorIOAsExcC e m a -> (e0 -> ErrorToErrorIOAsExcC e m a) -> ErrorToErrorIOAsExcC e m a #
MonadCatch m => MonadCatch (ErrorC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ErrorC e m a -> (e0 -> ErrorC e m a) -> ErrorC e m a #
MonadCatch m => MonadCatch (ThrowC e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ThrowC e m a -> (e0 -> ThrowC e m a) -> ThrowC e m a #
MonadCatch m => MonadCatch (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToErrorIOSimpleC exc m a -> (e -> SafeErrorToErrorIOSimpleC exc m a) -> SafeErrorToErrorIOSimpleC exc m a #
MonadCatch m => MonadCatch (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToIOSimpleC exc m a -> (e -> SafeErrorToIOSimpleC exc m a) -> SafeErrorToIOSimpleC exc m a #
MonadCatch m => MonadCatch (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorC exc m a -> (e -> SafeErrorC exc m a) -> SafeErrorC exc m a #
MonadCatch m => MonadCatch (BaseControlC m) Source #
Instance details Defined in Control.Effect.Internal.BaseControl Methods catch :: Exception e => BaseControlC m a -> (e -> BaseControlC m a) -> BaseControlC m a #
MonadCatch m => MonadCatch (FreshEnumC uniq m) Source #
Instance details Defined in Control.Effect.Fresh Methods catch :: Exception e => FreshEnumC uniq m a -> (e -> FreshEnumC uniq m a) -> FreshEnumC uniq m a #
MonadCatch m => MonadCatch (WriterTVarC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => WriterTVarC o m a -> (e -> WriterTVarC o m a) -> WriterTVarC o m a #
MonadCatch m => MonadCatch (ListenTVarC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => ListenTVarC o m a -> (e -> ListenTVarC o m a) -> ListenTVarC o m a #
MonadCatch m => MonadCatch (WriterToBracketC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => WriterToBracketC o m a -> (e -> WriterToBracketC o m a) -> WriterToBracketC o m a #
MonadCatch m => MonadCatch (WriterIntoEndoWriterC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => WriterIntoEndoWriterC o m a -> (e -> WriterIntoEndoWriterC o m a) -> WriterIntoEndoWriterC o m a #
MonadCatch m => MonadCatch (ListenIntoEndoListenC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => ListenIntoEndoListenC o m a -> (e -> ListenIntoEndoListenC o m a) -> ListenIntoEndoListenC o m a #
MonadCatch m => MonadCatch (TellListLazyC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => TellListLazyC o m a -> (e -> TellListLazyC o m a) -> TellListLazyC o m a #
MonadCatch m => MonadCatch (TellListC o m) Source #
Instance details Defined in Control.Effect.Writer Methods catch :: Exception e => TellListC o m a -> (e -> TellListC o m a) -> TellListC o m a #
MonadCatch m => MonadCatch (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free.Church.Alternate Methods catch :: Exception e => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #
MonadCatch m => MonadCatch (ShiftC r m) Source #
Instance details Defined in Control.Effect.Internal.Cont Methods catch :: Exception e => ShiftC r m a -> (e -> ShiftC r m a) -> ShiftC r m a #
MonadCatch m => MonadCatch (ContC r m) Source #
Instance details Defined in Control.Effect.Internal.Cont Methods catch :: Exception e => ContC r m a -> (e -> ContC r m a) -> ContC r m a #
MonadCatch m => MonadCatch (SteppedC e m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Stepped Methods catch :: Exception e0 => SteppedC e m a -> (e0 -> SteppedC e m a) -> SteppedC e m a #
MonadCatch m => MonadCatch (InterceptRC e m) Source #
Instance details Defined in Control.Effect.Internal.Intercept Methods catch :: Exception e0 => InterceptRC e m a -> (e0 -> InterceptRC e m a) -> InterceptRC e m a #
MonadCatch m => MonadCatch (ListenSteppedC w m) Source #
Instance details Defined in Control.Effect.Internal.Intercept Methods catch :: Exception e => ListenSteppedC w m a -> (e -> ListenSteppedC w m a) -> ListenSteppedC w m a #
MonadCatch m => MonadCatch (InterceptContC e m) Source #
Instance details Defined in Control.Effect.Internal.Intercept Methods catch :: Exception e0 => InterceptContC e m a -> (e0 -> InterceptContC e m a) -> InterceptContC e m a #
MonadCatch m => MonadCatch (InterpretFailC h m) Source #
Instance details Defined in Control.Effect.Fail Methods catch :: Exception e => InterpretFailC h m a -> (e -> InterpretFailC h m a) -> InterpretFailC h m a #
MonadCatch m => MonadCatch (InterpretAltC h m) Source #
Instance details Defined in Control.Effect.Alt Methods catch :: Exception e => InterpretAltC h m a -> (e -> InterpretAltC h m a) -> InterpretAltC h m a #
MonadCatch m => MonadCatch (SubsumeC e m) Source #
Instance details Defined in Control.Effect.Internal Methods catch :: Exception e0 => SubsumeC e m a -> (e0 -> SubsumeC e m a) -> SubsumeC e m a #
MonadCatch m => MonadCatch (IntroC top new m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Intro Methods catch :: Exception e => IntroC top new m a -> (e -> IntroC top new m a) -> IntroC top new m a #
MonadCatch m => MonadCatch (ReinterpretSimpleC e new m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => ReinterpretSimpleC e new m a -> (e0 -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a #
MonadCatch m => MonadCatch (InterpretC h e m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => InterpretC h e m a -> (e0 -> InterpretC h e m a) -> InterpretC h e m a #
MonadCatch m => MonadCatch (InterpretPrimC s e m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => InterpretPrimC s e m a -> (e0 -> InterpretPrimC s e m a) -> InterpretPrimC s e m a #
MonadCatch m => MonadCatch (UnionC l m) Source #
Instance details Defined in Control.Effect.Union Methods catch :: Exception e => UnionC l m a -> (e -> UnionC l m a) -> UnionC l m a #
MonadCatch m => MonadCatch (WrapC e e' m) Source #
Instance details Defined in Control.Effect.Internal.Newtype Methods catch :: Exception e0 => WrapC e e' m a -> (e0 -> WrapC e e' m a) -> WrapC e e' m a #
MonadCatch m => MonadCatch (SelectC s r m) Source #
Instance details Defined in Control.Effect.Internal.Select Methods catch :: Exception e => SelectC s r m a -> (e -> SelectC s r m a) -> SelectC s r m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
MonadCatch (t (u m)) => MonadCatch (ComposeT t u m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Compose Methods catch :: Exception e => ComposeT t u m a -> (e -> ComposeT t u m a) -> ComposeT t u m a #
Monad m => MonadCatch (ViaAlg s Bracket m) Source #
Instance details Defined in Control.Effect.Type.Bracket Methods catch :: Exception e => ViaAlg s Bracket m a -> (e -> ViaAlg s Bracket m a) -> ViaAlg s Bracket m a #
Monad m => MonadCatch (ViaAlg s Mask m) Source #
Instance details Defined in Control.Effect.Type.Mask Methods catch :: Exception e => ViaAlg s Mask m a -> (e -> ViaAlg s Mask m a) -> ViaAlg s Mask m a #
MonadCatch m => MonadCatch (ReinterpretC h e new m) Source #
Instance details Defined in Control.Effect.Carrier.Internal.Interpret Methods catch :: Exception e0 => ReinterpretC h e new m a -> (e0 -> ReinterpretC h e new m a) -> ReinterpretC h e new m a #
MonadCatch m => MonadCatch (UnionizeC b m) Source #
Instance details Defined in Control.Effect.Union Methods catch :: Exception e => UnionizeC b m a -> (e -> UnionizeC b m a) -> UnionizeC b m a #
MonadCatch m => MonadCatch (UnionizeHeadC b m) Source #
Instance details Defined in Control.Effect.Union Methods catch :: Exception e => UnionizeHeadC b m a -> (e -> UnionizeHeadC b m a) -> UnionizeHeadC b m a #
MonadCatch m => MonadCatch (ErrorToIOC' s s' e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => ErrorToIOC' s s' e m a -> (e0 -> ErrorToIOC' s s' e m a) -> ErrorToIOC' s s' e m a #
MonadCatch m => MonadCatch (InterpretErrorC' s s' e m) Source #
Instance details Defined in Control.Effect.Internal.Error Methods catch :: Exception e0 => InterpretErrorC' s s' e m a -> (e0 -> InterpretErrorC' s s' e m a) -> InterpretErrorC' s s' e m a #
MonadCatch m => MonadCatch (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToErrorIOC' s s' exc m a -> (e -> SafeErrorToErrorIOC' s s' exc m a) -> SafeErrorToErrorIOC' s s' exc m a #
MonadCatch m => MonadCatch (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToIOC' s s' exc m a -> (e -> SafeErrorToIOC' s s' exc m a) -> SafeErrorToIOC' s s' exc m a #
MonadCatch m => MonadCatch (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => ExceptionallyC eff exc m a -> (e -> ExceptionallyC eff exc m a) -> ExceptionallyC eff exc m a #
MonadCatch m => MonadCatch (GainBaseControlC b z m) Source #
Instance details Defined in Control.Effect.BaseControl Methods catch :: Exception e => GainBaseControlC b z m a -> (e -> GainBaseControlC b z m a) -> GainBaseControlC b z m a #

Carriers

data ExceptionallyC (eff :: Effect) (exc :: *) m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> ExceptionallyC eff exc m α #
MonadBaseControl b m => MonadBaseControl b (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (ExceptionallyC eff exc m) a # Methods liftBaseWith :: (RunInBase (ExceptionallyC eff exc m) b -> b a) -> ExceptionallyC eff exc m a # restoreM :: StM (ExceptionallyC eff exc m) a -> ExceptionallyC eff exc m a #
MonadTrans (ExceptionallyC eff exc :: (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> ExceptionallyC eff exc m a #
MonadTransControl (ExceptionallyC eff exc :: (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StT (ExceptionallyC eff exc) a # Methods liftWith :: Monad m => (Run (ExceptionallyC eff exc) -> m a) -> ExceptionallyC eff exc m a # restoreT :: Monad m => m (StT (ExceptionallyC eff exc) a) -> ExceptionallyC eff exc m a #
Monad m => Monad (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: ExceptionallyC eff exc m a -> (a -> ExceptionallyC eff exc m b) -> ExceptionallyC eff exc m b # (>>) :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b -> ExceptionallyC eff exc m b # return :: a -> ExceptionallyC eff exc m a #
Functor m => Functor (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b # (<$) :: a -> ExceptionallyC eff exc m b -> ExceptionallyC eff exc m a #
MonadFix m => MonadFix (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> ExceptionallyC eff exc m a) -> ExceptionallyC eff exc m a #
MonadFail m => MonadFail (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> ExceptionallyC eff exc m a #
Applicative m => Applicative (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> ExceptionallyC eff exc m a # (<>) :: ExceptionallyC eff exc m (a -> b) -> ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b # liftA2 :: (a -> b -> c) -> ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b -> ExceptionallyC eff exc m c # (>) :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b -> ExceptionallyC eff exc m b # (<*) :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m b -> ExceptionallyC eff exc m a #
MonadIO m => MonadIO (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> ExceptionallyC eff exc m a #
Alternative m => Alternative (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: ExceptionallyC eff exc m a # (<\|>) :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a # some :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m [a] # many :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m [a] #
MonadPlus m => MonadPlus (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: ExceptionallyC eff exc m a # mplus :: ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a #
MonadThrow m => MonadThrow (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> ExceptionallyC eff exc m a #
MonadCatch m => MonadCatch (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => ExceptionallyC eff exc m a -> (e -> ExceptionallyC eff exc m a) -> ExceptionallyC eff exc m a #
MonadMask m => MonadMask (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a) -> ExceptionallyC eff exc m b) -> ExceptionallyC eff exc m b # uninterruptibleMask :: ((forall a. ExceptionallyC eff exc m a -> ExceptionallyC eff exc m a) -> ExceptionallyC eff exc m b) -> ExceptionallyC eff exc m b # generalBracket :: ExceptionallyC eff exc m a -> (a -> ExitCase b -> ExceptionallyC eff exc m c) -> (a -> ExceptionallyC eff exc m b) -> ExceptionallyC eff exc m (b, c) #
Eff (Exceptional eff exc) m => Carrier (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (ExceptionallyC eff exc m) :: [Effect] Source # type Prims (ExceptionallyC eff exc m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (ExceptionallyC eff exc m)) (ExceptionallyC eff exc m) a Source # reformulate :: Monad z => Reformulation' (Derivs (ExceptionallyC eff exc m)) (Prims (ExceptionallyC eff exc m)) (ExceptionallyC eff exc m) z a Source # algDerivs :: Algebra' (Derivs (ExceptionallyC eff exc m)) (ExceptionallyC eff exc m) a Source #
type StT (ExceptionallyC eff exc :: (Type -> Type) -> Type -> Type) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StT (ExceptionallyC eff exc :: (Type -> Type) -> Type -> Type) a = StT (IdentityT :: (Type -> Type) -> Type -> Type) a
type Derivs (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (ExceptionallyC eff exc m) = Catch exc ': (eff ': Derivs m)
type Prims (ExceptionallyC eff exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (ExceptionallyC eff exc m) = Prims m
type StM (ExceptionallyC eff exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (ExceptionallyC eff exc m) a = StM m a

type ExceptionalC eff exc = InterpretC ExceptionalH (Exceptional eff exc) Source #

type SafeErrorToErrorC exc = ExceptionalC (Throw exc) exc Source #

data SafeErrorC exc m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> SafeErrorC exc m α #
MonadBaseControl b m => MonadBaseControl b (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (SafeErrorC exc m) a # Methods liftBaseWith :: (RunInBase (SafeErrorC exc m) b -> b a) -> SafeErrorC exc m a # restoreM :: StM (SafeErrorC exc m) a -> SafeErrorC exc m a #
MonadTrans (SafeErrorC exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> SafeErrorC exc m a #
MonadTransControl (SafeErrorC exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StT (SafeErrorC exc) a # Methods liftWith :: Monad m => (Run (SafeErrorC exc) -> m a) -> SafeErrorC exc m a # restoreT :: Monad m => m (StT (SafeErrorC exc) a) -> SafeErrorC exc m a #
Monad m => Monad (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: SafeErrorC exc m a -> (a -> SafeErrorC exc m b) -> SafeErrorC exc m b # (>>) :: SafeErrorC exc m a -> SafeErrorC exc m b -> SafeErrorC exc m b # return :: a -> SafeErrorC exc m a #
Functor m => Functor (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> SafeErrorC exc m a -> SafeErrorC exc m b # (<$) :: a -> SafeErrorC exc m b -> SafeErrorC exc m a #
MonadFix m => MonadFix (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> SafeErrorC exc m a) -> SafeErrorC exc m a #
MonadFail m => MonadFail (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> SafeErrorC exc m a #
Monad m => Applicative (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> SafeErrorC exc m a # (<>) :: SafeErrorC exc m (a -> b) -> SafeErrorC exc m a -> SafeErrorC exc m b # liftA2 :: (a -> b -> c) -> SafeErrorC exc m a -> SafeErrorC exc m b -> SafeErrorC exc m c # (>) :: SafeErrorC exc m a -> SafeErrorC exc m b -> SafeErrorC exc m b # (<*) :: SafeErrorC exc m a -> SafeErrorC exc m b -> SafeErrorC exc m a #
MonadIO m => MonadIO (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> SafeErrorC exc m a #
(Monad m, Monoid exc) => Alternative (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: SafeErrorC exc m a # (<\|>) :: SafeErrorC exc m a -> SafeErrorC exc m a -> SafeErrorC exc m a # some :: SafeErrorC exc m a -> SafeErrorC exc m [a] # many :: SafeErrorC exc m a -> SafeErrorC exc m [a] #
(Monad m, Monoid exc) => MonadPlus (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: SafeErrorC exc m a # mplus :: SafeErrorC exc m a -> SafeErrorC exc m a -> SafeErrorC exc m a #
MonadThrow m => MonadThrow (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> SafeErrorC exc m a #
MonadCatch m => MonadCatch (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorC exc m a -> (e -> SafeErrorC exc m a) -> SafeErrorC exc m a #
MonadMask m => MonadMask (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. SafeErrorC exc m a -> SafeErrorC exc m a) -> SafeErrorC exc m b) -> SafeErrorC exc m b # uninterruptibleMask :: ((forall a. SafeErrorC exc m a -> SafeErrorC exc m a) -> SafeErrorC exc m b) -> SafeErrorC exc m b # generalBracket :: SafeErrorC exc m a -> (a -> ExitCase b -> SafeErrorC exc m c) -> (a -> SafeErrorC exc m b) -> SafeErrorC exc m (b, c) #
(Carrier m, Threads (ExceptT exc) (Prims m)) => Carrier (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (SafeErrorC exc m) :: [Effect] Source # type Prims (SafeErrorC exc m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (SafeErrorC exc m)) (SafeErrorC exc m) a Source # reformulate :: Monad z => Reformulation' (Derivs (SafeErrorC exc m)) (Prims (SafeErrorC exc m)) (SafeErrorC exc m) z a Source # algDerivs :: Algebra' (Derivs (SafeErrorC exc m)) (SafeErrorC exc m) a Source #
type StT (SafeErrorC exc) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StT (SafeErrorC exc) a = StT (CompositionBaseT '[IntroUnderC (SafeError exc) '[Catch exc, Throw exc], SafeErrorToErrorC exc, ErrorC exc]) a
type Derivs (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (SafeErrorC exc m) = Derivs (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorC exc m)))
type Prims (SafeErrorC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (SafeErrorC exc m) = Prims (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorC exc m)))
type StM (SafeErrorC exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (SafeErrorC exc m) a = StM (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorC exc m))) a

data SafeErrorToIOC' s s' exc m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> SafeErrorToIOC' s s' exc m α #
MonadBaseControl b m => MonadBaseControl b (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (SafeErrorToIOC' s s' exc m) a # Methods liftBaseWith :: (RunInBase (SafeErrorToIOC' s s' exc m) b -> b a) -> SafeErrorToIOC' s s' exc m a # restoreM :: StM (SafeErrorToIOC' s s' exc m) a -> SafeErrorToIOC' s s' exc m a #
MonadTrans (SafeErrorToIOC' s s' exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> SafeErrorToIOC' s s' exc m a #
MonadTransControl (SafeErrorToIOC' s s' exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StT (SafeErrorToIOC' s s' exc) a # Methods liftWith :: Monad m => (Run (SafeErrorToIOC' s s' exc) -> m a) -> SafeErrorToIOC' s s' exc m a # restoreT :: Monad m => m (StT (SafeErrorToIOC' s s' exc) a) -> SafeErrorToIOC' s s' exc m a #
Monad m => Monad (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: SafeErrorToIOC' s s' exc m a -> (a -> SafeErrorToIOC' s s' exc m b) -> SafeErrorToIOC' s s' exc m b # (>>) :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b -> SafeErrorToIOC' s s' exc m b # return :: a -> SafeErrorToIOC' s s' exc m a #
Functor m => Functor (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b # (<$) :: a -> SafeErrorToIOC' s s' exc m b -> SafeErrorToIOC' s s' exc m a #
MonadFix m => MonadFix (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> SafeErrorToIOC' s s' exc m a) -> SafeErrorToIOC' s s' exc m a #
MonadFail m => MonadFail (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> SafeErrorToIOC' s s' exc m a #
Applicative m => Applicative (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> SafeErrorToIOC' s s' exc m a # (<>) :: SafeErrorToIOC' s s' exc m (a -> b) -> SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b # liftA2 :: (a -> b -> c) -> SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b -> SafeErrorToIOC' s s' exc m c # (>) :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b -> SafeErrorToIOC' s s' exc m b # (<*) :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m b -> SafeErrorToIOC' s s' exc m a #
MonadIO m => MonadIO (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> SafeErrorToIOC' s s' exc m a #
Alternative m => Alternative (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: SafeErrorToIOC' s s' exc m a # (<\|>) :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a # some :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m [a] # many :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m [a] #
MonadPlus m => MonadPlus (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: SafeErrorToIOC' s s' exc m a # mplus :: SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a #
MonadThrow m => MonadThrow (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> SafeErrorToIOC' s s' exc m a #
MonadCatch m => MonadCatch (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToIOC' s s' exc m a -> (e -> SafeErrorToIOC' s s' exc m a) -> SafeErrorToIOC' s s' exc m a #
MonadMask m => MonadMask (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a) -> SafeErrorToIOC' s s' exc m b) -> SafeErrorToIOC' s s' exc m b # uninterruptibleMask :: ((forall a. SafeErrorToIOC' s s' exc m a -> SafeErrorToIOC' s s' exc m a) -> SafeErrorToIOC' s s' exc m b) -> SafeErrorToIOC' s s' exc m b # generalBracket :: SafeErrorToIOC' s s' exc m a -> (a -> ExitCase b -> SafeErrorToIOC' s s' exc m c) -> (a -> SafeErrorToIOC' s s' exc m b) -> SafeErrorToIOC' s s' exc m (b, c) #
(Eff (Embed IO) m, MonadCatch m, ReifiesErrorHandler s s' exc (ErrorIOToIOC m)) => Carrier (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (SafeErrorToIOC' s s' exc m) :: [Effect] Source # type Prims (SafeErrorToIOC' s s' exc m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (SafeErrorToIOC' s s' exc m)) (SafeErrorToIOC' s s' exc m) a Source # reformulate :: Monad z => Reformulation' (Derivs (SafeErrorToIOC' s s' exc m)) (Prims (SafeErrorToIOC' s s' exc m)) (SafeErrorToIOC' s s' exc m) z a Source # algDerivs :: Algebra' (Derivs (SafeErrorToIOC' s s' exc m)) (SafeErrorToIOC' s s' exc m) a Source #
type StT (SafeErrorToIOC' s s' exc) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StT (SafeErrorToIOC' s s' exc) a = StT (CompositionBaseT '[IntroUnderC (SafeError exc) '[Catch exc, Throw exc], SafeErrorToErrorC exc, ErrorToIOC' s s' exc]) a
type Derivs (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (SafeErrorToIOC' s s' exc m) = Derivs (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorToIOC' s s' exc m)))
type Prims (SafeErrorToIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (SafeErrorToIOC' s s' exc m) = Prims (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorToIOC' s s' exc m)))
type StM (SafeErrorToIOC' s s' exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (SafeErrorToIOC' s s' exc m) a = StM (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorToIOC' s s' exc m))) a

type SafeErrorToIOC e m a = forall s s'. ReifiesErrorHandler s s' e (ErrorIOToIOC m) => SafeErrorToIOC' s s' e m a Source #

data SafeErrorToErrorIOC' s s' exc m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> SafeErrorToErrorIOC' s s' exc m α #
MonadBaseControl b m => MonadBaseControl b (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (SafeErrorToErrorIOC' s s' exc m) a # Methods liftBaseWith :: (RunInBase (SafeErrorToErrorIOC' s s' exc m) b -> b a) -> SafeErrorToErrorIOC' s s' exc m a # restoreM :: StM (SafeErrorToErrorIOC' s s' exc m) a -> SafeErrorToErrorIOC' s s' exc m a #
MonadTrans (SafeErrorToErrorIOC' s s' exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> SafeErrorToErrorIOC' s s' exc m a #
MonadTransControl (SafeErrorToErrorIOC' s s' exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StT (SafeErrorToErrorIOC' s s' exc) a # Methods liftWith :: Monad m => (Run (SafeErrorToErrorIOC' s s' exc) -> m a) -> SafeErrorToErrorIOC' s s' exc m a # restoreT :: Monad m => m (StT (SafeErrorToErrorIOC' s s' exc) a) -> SafeErrorToErrorIOC' s s' exc m a #
Monad m => Monad (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: SafeErrorToErrorIOC' s s' exc m a -> (a -> SafeErrorToErrorIOC' s s' exc m b) -> SafeErrorToErrorIOC' s s' exc m b # (>>) :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b -> SafeErrorToErrorIOC' s s' exc m b # return :: a -> SafeErrorToErrorIOC' s s' exc m a #
Functor m => Functor (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b # (<$) :: a -> SafeErrorToErrorIOC' s s' exc m b -> SafeErrorToErrorIOC' s s' exc m a #
MonadFix m => MonadFix (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> SafeErrorToErrorIOC' s s' exc m a) -> SafeErrorToErrorIOC' s s' exc m a #
MonadFail m => MonadFail (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> SafeErrorToErrorIOC' s s' exc m a #
Applicative m => Applicative (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> SafeErrorToErrorIOC' s s' exc m a # (<>) :: SafeErrorToErrorIOC' s s' exc m (a -> b) -> SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b # liftA2 :: (a -> b -> c) -> SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b -> SafeErrorToErrorIOC' s s' exc m c # (>) :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b -> SafeErrorToErrorIOC' s s' exc m b # (<*) :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m b -> SafeErrorToErrorIOC' s s' exc m a #
MonadIO m => MonadIO (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> SafeErrorToErrorIOC' s s' exc m a #
Alternative m => Alternative (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: SafeErrorToErrorIOC' s s' exc m a # (<\|>) :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a # some :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m [a] # many :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m [a] #
MonadPlus m => MonadPlus (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: SafeErrorToErrorIOC' s s' exc m a # mplus :: SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a #
MonadThrow m => MonadThrow (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> SafeErrorToErrorIOC' s s' exc m a #
MonadCatch m => MonadCatch (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToErrorIOC' s s' exc m a -> (e -> SafeErrorToErrorIOC' s s' exc m a) -> SafeErrorToErrorIOC' s s' exc m a #
MonadMask m => MonadMask (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a) -> SafeErrorToErrorIOC' s s' exc m b) -> SafeErrorToErrorIOC' s s' exc m b # uninterruptibleMask :: ((forall a. SafeErrorToErrorIOC' s s' exc m a -> SafeErrorToErrorIOC' s s' exc m a) -> SafeErrorToErrorIOC' s s' exc m b) -> SafeErrorToErrorIOC' s s' exc m b # generalBracket :: SafeErrorToErrorIOC' s s' exc m a -> (a -> ExitCase b -> SafeErrorToErrorIOC' s s' exc m c) -> (a -> SafeErrorToErrorIOC' s s' exc m b) -> SafeErrorToErrorIOC' s s' exc m (b, c) #
(Carrier m, ReifiesErrorHandler s s' exc m) => Carrier (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (SafeErrorToErrorIOC' s s' exc m) :: [Effect] Source # type Prims (SafeErrorToErrorIOC' s s' exc m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (SafeErrorToErrorIOC' s s' exc m)) (SafeErrorToErrorIOC' s s' exc m) a Source # reformulate :: Monad z => Reformulation' (Derivs (SafeErrorToErrorIOC' s s' exc m)) (Prims (SafeErrorToErrorIOC' s s' exc m)) (SafeErrorToErrorIOC' s s' exc m) z a Source # algDerivs :: Algebra' (Derivs (SafeErrorToErrorIOC' s s' exc m)) (SafeErrorToErrorIOC' s s' exc m) a Source #
type StT (SafeErrorToErrorIOC' s s' exc) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StT (SafeErrorToErrorIOC' s s' exc) a = StT (CompositionBaseT '[IntroUnderC (SafeError exc) '[Catch exc, Throw exc], SafeErrorToErrorC exc, InterpretErrorC' s s' exc]) a
type Derivs (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (SafeErrorToErrorIOC' s s' exc m) = Derivs (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (InterpretErrorC' s s' exc m)))
type Prims (SafeErrorToErrorIOC' s s' exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (SafeErrorToErrorIOC' s s' exc m) = Prims (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (InterpretErrorC' s s' exc m)))
type StM (SafeErrorToErrorIOC' s s' exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (SafeErrorToErrorIOC' s s' exc m) a = StM (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (InterpretErrorC' s s' exc m))) a

type SafeErrorToErrorIOC e m a = forall s s'. ReifiesErrorHandler s s' e m => SafeErrorToErrorIOC' s s' e m a Source #

data SafeErrorToIOSimpleC exc m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> SafeErrorToIOSimpleC exc m α #
MonadBaseControl b m => MonadBaseControl b (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (SafeErrorToIOSimpleC exc m) a # Methods liftBaseWith :: (RunInBase (SafeErrorToIOSimpleC exc m) b -> b a) -> SafeErrorToIOSimpleC exc m a # restoreM :: StM (SafeErrorToIOSimpleC exc m) a -> SafeErrorToIOSimpleC exc m a #
MonadTrans (SafeErrorToIOSimpleC exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> SafeErrorToIOSimpleC exc m a #
Monad m => Monad (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: SafeErrorToIOSimpleC exc m a -> (a -> SafeErrorToIOSimpleC exc m b) -> SafeErrorToIOSimpleC exc m b # (>>) :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b -> SafeErrorToIOSimpleC exc m b # return :: a -> SafeErrorToIOSimpleC exc m a #
Functor m => Functor (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b # (<$) :: a -> SafeErrorToIOSimpleC exc m b -> SafeErrorToIOSimpleC exc m a #
MonadFix m => MonadFix (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> SafeErrorToIOSimpleC exc m a) -> SafeErrorToIOSimpleC exc m a #
MonadFail m => MonadFail (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> SafeErrorToIOSimpleC exc m a #
Applicative m => Applicative (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> SafeErrorToIOSimpleC exc m a # (<>) :: SafeErrorToIOSimpleC exc m (a -> b) -> SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b # liftA2 :: (a -> b -> c) -> SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b -> SafeErrorToIOSimpleC exc m c # (>) :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b -> SafeErrorToIOSimpleC exc m b # (<*) :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m b -> SafeErrorToIOSimpleC exc m a #
MonadIO m => MonadIO (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> SafeErrorToIOSimpleC exc m a #
Alternative m => Alternative (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: SafeErrorToIOSimpleC exc m a # (<\|>) :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a # some :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m [a] # many :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m [a] #
MonadPlus m => MonadPlus (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: SafeErrorToIOSimpleC exc m a # mplus :: SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a #
MonadThrow m => MonadThrow (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> SafeErrorToIOSimpleC exc m a #
MonadCatch m => MonadCatch (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToIOSimpleC exc m a -> (e -> SafeErrorToIOSimpleC exc m a) -> SafeErrorToIOSimpleC exc m a #
MonadMask m => MonadMask (SafeErrorToIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a) -> SafeErrorToIOSimpleC exc m b) -> SafeErrorToIOSimpleC exc m b # uninterruptibleMask :: ((forall a. SafeErrorToIOSimpleC exc m a -> SafeErrorToIOSimpleC exc m a) -> SafeErrorToIOSimpleC exc m b) -> SafeErrorToIOSimpleC exc m b # generalBracket :: SafeErrorToIOSimpleC exc m a -> (a -> ExitCase b -> SafeErrorToIOSimpleC exc m c) -> (a -> SafeErrorToIOSimpleC exc m b) -> SafeErrorToIOSimpleC exc m (b, c) #
(Eff (Embed IO) m, MonadCatch m, Threaders '[ReaderThreads] m p) => Carrier (SafeErrorToIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (SafeErrorToIOSimpleC e m) :: [Effect] Source # type Prims (SafeErrorToIOSimpleC e m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (SafeErrorToIOSimpleC e m)) (SafeErrorToIOSimpleC e m) a Source # reformulate :: Monad z => Reformulation' (Derivs (SafeErrorToIOSimpleC e m)) (Prims (SafeErrorToIOSimpleC e m)) (SafeErrorToIOSimpleC e m) z a Source # algDerivs :: Algebra' (Derivs (SafeErrorToIOSimpleC e m)) (SafeErrorToIOSimpleC e m) a Source #
type Derivs (SafeErrorToIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (SafeErrorToIOSimpleC e m) = Derivs (IntroC '[SafeError e] '[Catch e, Throw e] (SafeErrorToErrorC e (ErrorToIOSimpleC e m)))
type Prims (SafeErrorToIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (SafeErrorToIOSimpleC e m) = Prims (IntroC '[SafeError e] '[Catch e, Throw e] (SafeErrorToErrorC e (ErrorToIOSimpleC e m)))
type StM (SafeErrorToIOSimpleC exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (SafeErrorToIOSimpleC exc m) a = StM (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (ErrorToIOSimpleC exc m))) a

data SafeErrorToErrorIOSimpleC exc m a Source #

Instances

Instances details

MonadBase b m => MonadBase b (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftBase :: b α -> SafeErrorToErrorIOSimpleC exc m α #
MonadBaseControl b m => MonadBaseControl b (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type StM (SafeErrorToErrorIOSimpleC exc m) a # Methods liftBaseWith :: (RunInBase (SafeErrorToErrorIOSimpleC exc m) b -> b a) -> SafeErrorToErrorIOSimpleC exc m a # restoreM :: StM (SafeErrorToErrorIOSimpleC exc m) a -> SafeErrorToErrorIOSimpleC exc m a #
MonadTrans (SafeErrorToErrorIOSimpleC exc) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods lift :: Monad m => m a -> SafeErrorToErrorIOSimpleC exc m a #
Monad m => Monad (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods (>>=) :: SafeErrorToErrorIOSimpleC exc m a -> (a -> SafeErrorToErrorIOSimpleC exc m b) -> SafeErrorToErrorIOSimpleC exc m b # (>>) :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b -> SafeErrorToErrorIOSimpleC exc m b # return :: a -> SafeErrorToErrorIOSimpleC exc m a #
Functor m => Functor (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fmap :: (a -> b) -> SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b # (<$) :: a -> SafeErrorToErrorIOSimpleC exc m b -> SafeErrorToErrorIOSimpleC exc m a #
MonadFix m => MonadFix (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mfix :: (a -> SafeErrorToErrorIOSimpleC exc m a) -> SafeErrorToErrorIOSimpleC exc m a #
MonadFail m => MonadFail (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods fail :: String -> SafeErrorToErrorIOSimpleC exc m a #
Applicative m => Applicative (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods pure :: a -> SafeErrorToErrorIOSimpleC exc m a # (<>) :: SafeErrorToErrorIOSimpleC exc m (a -> b) -> SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b # liftA2 :: (a -> b -> c) -> SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b -> SafeErrorToErrorIOSimpleC exc m c # (>) :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b -> SafeErrorToErrorIOSimpleC exc m b # (<*) :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m b -> SafeErrorToErrorIOSimpleC exc m a #
MonadIO m => MonadIO (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods liftIO :: IO a -> SafeErrorToErrorIOSimpleC exc m a #
Alternative m => Alternative (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods empty :: SafeErrorToErrorIOSimpleC exc m a # (<\|>) :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a # some :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m [a] # many :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m [a] #
MonadPlus m => MonadPlus (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mzero :: SafeErrorToErrorIOSimpleC exc m a # mplus :: SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a #
MonadThrow m => MonadThrow (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods throwM :: Exception e => e -> SafeErrorToErrorIOSimpleC exc m a #
MonadCatch m => MonadCatch (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods catch :: Exception e => SafeErrorToErrorIOSimpleC exc m a -> (e -> SafeErrorToErrorIOSimpleC exc m a) -> SafeErrorToErrorIOSimpleC exc m a #
MonadMask m => MonadMask (SafeErrorToErrorIOSimpleC exc m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Methods mask :: ((forall a. SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a) -> SafeErrorToErrorIOSimpleC exc m b) -> SafeErrorToErrorIOSimpleC exc m b # uninterruptibleMask :: ((forall a. SafeErrorToErrorIOSimpleC exc m a -> SafeErrorToErrorIOSimpleC exc m a) -> SafeErrorToErrorIOSimpleC exc m b) -> SafeErrorToErrorIOSimpleC exc m b # generalBracket :: SafeErrorToErrorIOSimpleC exc m a -> (a -> ExitCase b -> SafeErrorToErrorIOSimpleC exc m c) -> (a -> SafeErrorToErrorIOSimpleC exc m b) -> SafeErrorToErrorIOSimpleC exc m (b, c) #
(Carrier m, Threaders '[ReaderThreads] m p) => Carrier (SafeErrorToErrorIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional Associated Types type Derivs (SafeErrorToErrorIOSimpleC e m) :: [Effect] Source # type Prims (SafeErrorToErrorIOSimpleC e m) :: [Effect] Source # Methods algPrims :: Algebra' (Prims (SafeErrorToErrorIOSimpleC e m)) (SafeErrorToErrorIOSimpleC e m) a Source # reformulate :: Monad z => Reformulation' (Derivs (SafeErrorToErrorIOSimpleC e m)) (Prims (SafeErrorToErrorIOSimpleC e m)) (SafeErrorToErrorIOSimpleC e m) z a Source # algDerivs :: Algebra' (Derivs (SafeErrorToErrorIOSimpleC e m)) (SafeErrorToErrorIOSimpleC e m) a Source #
type Derivs (SafeErrorToErrorIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Derivs (SafeErrorToErrorIOSimpleC e m) = Derivs (IntroC '[SafeError e] '[Catch e, Throw e] (SafeErrorToErrorC e (InterpretErrorSimpleC e m)))
type Prims (SafeErrorToErrorIOSimpleC e m) Source #
Instance details Defined in Control.Effect.Internal.Exceptional type Prims (SafeErrorToErrorIOSimpleC e m) = Prims (IntroC '[SafeError e] '[Catch e, Throw e] (SafeErrorToErrorC e (InterpretErrorSimpleC e m)))
type StM (SafeErrorToErrorIOSimpleC exc m) a Source #
Instance details Defined in Control.Effect.Internal.Exceptional type StM (SafeErrorToErrorIOSimpleC exc m) a = StM (IntroC '[SafeError exc] '[Catch exc, Throw exc] (SafeErrorToErrorC exc (InterpretErrorSimpleC exc m))) a