in-other-words-0.2.0.0: A higher-order effect system where the sky's the limit
Safe HaskellNone
LanguageHaskell2010

Control.Effect.Bracket

Synopsis

Effects

data Bracket :: Effect where Source #

An effect for exception-safe acquisition and release of resources.

Bracket is typically used as a primitive effect. If you define a Carrier that relies on a novel non-trivial monad transformer t, then you need to make a ThreadsEff t Bracket instance (if possible). threadBracketViaClass can help you with that.

The following threading constraints accept Bracket:

Constructors

GeneralBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> Bracket m (b, c) 

Instances

Instances details
ThreadsEff (ExceptT e) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (ExceptT e m) a -> ExceptT e m a Source #

Monoid s => ThreadsEff (WriterT s) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (WriterT s m) a -> WriterT s m a Source #

ThreadsEff (StateT s) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (StateT s m) a -> StateT s m a Source #

ThreadsEff (ReaderT i) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (ReaderT i m) a -> ReaderT i m a Source #

ThreadsEff (StateT s) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (StateT s m) a -> StateT s m a Source #

Monoid s => ThreadsEff (WriterT s) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (WriterT s m) a -> WriterT s m a Source #

Monoid s => ThreadsEff (WriterT s) Bracket Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (WriterT s m) a -> WriterT s m a Source #

Monad m => MonadThrow (ViaAlg s Bracket m) Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

throwM :: Exception e => e -> ViaAlg s Bracket 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 #

(Reifies s (ReifiedEffAlgebra Bracket m), Monad m) => MonadMask (ViaAlg s Bracket m) Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

mask :: ((forall a. ViaAlg s Bracket m a -> ViaAlg s Bracket m a) -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m b #

uninterruptibleMask :: ((forall a. ViaAlg s Bracket m a -> ViaAlg s Bracket m a) -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m b #

generalBracket :: ViaAlg s Bracket m a -> (a -> ExitCase b -> ViaAlg s Bracket m c) -> (a -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m (b, c) #

data ExitCase a #

A MonadMask computation may either succeed with a value, abort with an exception, or abort for some other reason. For example, in ExceptT e IO you can use throwM to abort with an exception (ExitCaseException) or throwE to abort with a value of type e (ExitCaseAbort).

Instances

Instances details
Show a => Show (ExitCase a) 
Instance details

Defined in Control.Monad.Catch

Methods

showsPrec :: Int -> ExitCase a -> ShowS #

show :: ExitCase a -> String #

showList :: [ExitCase a] -> ShowS #

Actions

generalBracket :: Eff Bracket m => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c) Source #

bracket :: Eff Bracket m => m a -> (a -> m c) -> (a -> m b) -> m b Source #

bracket_ :: Eff Bracket m => m a -> m c -> m b -> m b Source #

bracketOnError :: Eff Bracket m => m a -> (a -> m c) -> (a -> m b) -> m b Source #

onError :: Eff Bracket m => m a -> m b -> m a Source #

finally :: Eff Bracket m => m a -> m b -> m a Source #

Interpretations

bracketToIO :: (Carrier m, MonadMask m) => BracketToIOC m a -> m a Source #

Run a Bracket by effect that protects against any abortive computation of any effect, as well as any IO exceptions and asynchronous exceptions.

Any generalBracket will have its cleanup action be executed uninterruptibly masked. This means that the cleanup action cannot, under any circumstance, be interrupted by asynchronous exceptions.

Derivs (BracketToIOC m) = Bracket ': Derivs m
Prims  (BracketToIOC m) = Bracket ': Prims m

bracketToIOUnsafe :: (Carrier m, MonadMask m) => BracketToIOUnsafeC m a -> m a Source #

Run a Bracket by effect that protects against any abortive computation of any effect, as well as any IO exceptions and asynchronous exceptions.

Any generalBracket will have its cleanup action be executed interruptibly masked. This means that the cleanup action can be interrupted by asynchronous exceptions if the cleanup action executes interruptible (blocking) operations, such as putMVar.

Derivs (BracketToIOUnsafeC m) = Bracket ': Derivs m
Prims  (BracketToIOUnsafeC m) = Bracket ': Prims m

Since: 0.2.0.0

runBracketLocally :: Carrier m => BracketLocallyC m a -> m a Source #

Run a Bracket effect that protects against any abortive computations of purely local effects -- i.e. effects interpreted before runBracketLocally that are not interpreted in terms of the final monad nor other effects interpreted after runBracketLocally.

This does not protect against IO exceptions of any kind, including asynchronous exceptions.

This is more situational compared to bracketToIO, but can be useful. For an example, see the wiki.

Derivs (BracketLocallyC m) = Bracket ': Derivs m
Prims  (BracketLocallyC m) = Bracket ': Prims m

ignoreBracket :: Carrier m => IgnoreBracketC m a -> m a Source #

Run a Bracket effect by ignoring it, providing no protection at all.

Derivs (IgnoreBracketC m) = Bracket ': Derivs m
Prims  (IgnoreBracketC m) = Prims m

Threading utilities

threadBracketViaClass :: forall t m a. Monad m => (RepresentationalT t, forall b. MonadMask b => MonadMask (t b)) => (forall x. Bracket m x -> m x) -> Bracket (t m) a -> t m a Source #

A valid definition of threadEff for a ThreadsEff t Bracket instance, given that t lifts MonadMask.

BEWARE: threadBracketViaClass is only safe if the implementation of generalBracket for t m only makes use of generalBracket for m, and no other methods of MonadThrow, MonadCatch, or MonadMask.

MonadMask

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

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

fg = f `finally` g

The action g is called regardless of what occurs within f, including async exceptions. Some monads allow f to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If f and g both throw an error, the error thrown by fg depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, ExceptT e1 (Except e2) a represents a value of type Either e2 (Either e1 a), so throwing both an e1 and an e2 will result in Left e2. If f and g both throw an error from the same layer, instances should ensure that the error from g wins.

Effects other than throwing an error are also overriden by the deeper layers. For example, StateT s Maybe a represents a value of type s -> Maybe (a, s), so if an error thrown from f causes this function to return Nothing, any changes to the state which f also performed will be erased. As a result, g will see the state as it was before f. Once g completes, f's error will be rethrown, so g' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of finally always discards all of g's non-IO effects, and g never sees any of f's non-IO effects, regardless of the layer ordering and regardless of whether f throws an error. This is not the result of interacting effects, but a consequence of MonadBaseControl's approach.

Minimal complete definition

mask, uninterruptibleMask, generalBracket

Instances

Instances details
MonadMask IO 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) #

e ~ SomeException => MonadMask (Either e)

Since: exceptions-0.8.3

Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #

MonadMask m => MonadMask (MaybeT m)

Since: exceptions-0.10.0

Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b #

uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b #

generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #

MonadMask m => MonadMask (ErrorIOToIOC m) Source # 
Instance details

Defined in Control.Effect.Internal.ErrorIO

Methods

mask :: ((forall a. ErrorIOToIOC m a -> ErrorIOToIOC m a) -> ErrorIOToIOC m b) -> ErrorIOToIOC m b #

uninterruptibleMask :: ((forall a. ErrorIOToIOC m a -> ErrorIOToIOC m a) -> ErrorIOToIOC m b) -> ErrorIOToIOC m b #

generalBracket :: ErrorIOToIOC m a -> (a -> ExitCase b -> ErrorIOToIOC m c) -> (a -> ErrorIOToIOC m b) -> ErrorIOToIOC m (b, c) #

MonadMask m => MonadMask (ConcToIOC m) Source # 
Instance details

Defined in Control.Effect.Internal.Conc

Methods

mask :: ((forall a. ConcToIOC m a -> ConcToIOC m a) -> ConcToIOC m b) -> ConcToIOC m b #

uninterruptibleMask :: ((forall a. ConcToIOC m a -> ConcToIOC m a) -> ConcToIOC m b) -> ConcToIOC m b #

generalBracket :: ConcToIOC m a -> (a -> ExitCase b -> ConcToIOC m c) -> (a -> ConcToIOC m b) -> ConcToIOC m (b, c) #

MonadMask m => MonadMask (TraceListC m) Source # 
Instance details

Defined in Control.Effect.Trace

Methods

mask :: ((forall a. TraceListC m a -> TraceListC m a) -> TraceListC m b) -> TraceListC m b #

uninterruptibleMask :: ((forall a. TraceListC m a -> TraceListC m a) -> TraceListC m b) -> TraceListC m b #

generalBracket :: TraceListC m a -> (a -> ExitCase b -> TraceListC m c) -> (a -> TraceListC m b) -> TraceListC m (b, c) #

MonadMask m => MonadMask (InterpretFailSimpleC m) Source # 
Instance details

Defined in Control.Effect.Fail

MonadMask m => MonadMask (FailC m) Source # 
Instance details

Defined in Control.Effect.Fail

Methods

mask :: ((forall a. FailC m a -> FailC m a) -> FailC m b) -> FailC m b #

uninterruptibleMask :: ((forall a. FailC m a -> FailC m a) -> FailC m b) -> FailC m b #

generalBracket :: FailC m a -> (a -> ExitCase b -> FailC m c) -> (a -> FailC m b) -> FailC m (b, c) #

MonadMask m => MonadMask (AltMaybeC m) Source # 
Instance details

Defined in Control.Effect.Alt

Methods

mask :: ((forall a. AltMaybeC m a -> AltMaybeC m a) -> AltMaybeC m b) -> AltMaybeC m b #

uninterruptibleMask :: ((forall a. AltMaybeC m a -> AltMaybeC m a) -> AltMaybeC m b) -> AltMaybeC m b #

generalBracket :: AltMaybeC m a -> (a -> ExitCase b -> AltMaybeC m c) -> (a -> AltMaybeC m b) -> AltMaybeC m (b, c) #

MonadMask m => MonadMask (InterpretAltSimpleC m) Source # 
Instance details

Defined in Control.Effect.Alt

MonadMask m => MonadMask (ExceptT e m)

Since: exceptions-0.9.0

Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b #

uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b #

generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) #

(MonadMask m, Monoid w) => MonadMask (WriterT w m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #

MonadMask m => MonadMask (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #

MonadMask m => MonadMask (ReaderT r m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b #

uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b #

generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) #

(Error e, MonadMask m) => MonadMask (ErrorT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b #

uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b #

generalBracket :: ErrorT e m a -> (a -> ExitCase b -> ErrorT e m c) -> (a -> ErrorT e m b) -> ErrorT e m (b, c) #

MonadMask m => MonadMask (IdentityT m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b #

uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b #

generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c) #

MonadMask m => MonadMask (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #

(MonadMask m, Monoid w) => MonadMask (WriterT w m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #

MonadMask (CompositionBaseT ts m) => MonadMask (CompositionC ts m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Compose

Methods

mask :: ((forall a. CompositionC ts m a -> CompositionC ts m a) -> CompositionC ts m b) -> CompositionC ts m b #

uninterruptibleMask :: ((forall a. CompositionC ts m a -> CompositionC ts m a) -> CompositionC ts m b) -> CompositionC ts m b #

generalBracket :: CompositionC ts m a -> (a -> ExitCase b -> CompositionC ts m c) -> (a -> CompositionC ts m b) -> CompositionC ts m (b, c) #

Effs '[Mask, Bracket, ErrorIO] m => MonadMask (Effly m) Source # 
Instance details

Defined in Control.Effect.Internal.Effly

Methods

mask :: ((forall a. Effly m a -> Effly m a) -> Effly m b) -> Effly m b #

uninterruptibleMask :: ((forall a. Effly m a -> Effly m a) -> Effly m b) -> Effly m b #

generalBracket :: Effly m a -> (a -> ExitCase b -> Effly m c) -> (a -> Effly m b) -> Effly m (b, c) #

MonadMask m => MonadMask (InterpretPrimSimpleC e m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

MonadMask m => MonadMask (InterpretSimpleC e m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

Methods

mask :: ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a) -> InterpretSimpleC e m b) -> InterpretSimpleC e m b #

uninterruptibleMask :: ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a) -> InterpretSimpleC e m b) -> InterpretSimpleC e m b #

generalBracket :: InterpretSimpleC e m a -> (a -> ExitCase b -> InterpretSimpleC e m c) -> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m (b, c) #

MonadMask m => MonadMask (EmbedC m) Source # 
Instance details

Defined in Control.Effect.Embed

Methods

mask :: ((forall a. EmbedC m a -> EmbedC m a) -> EmbedC m b) -> EmbedC m b #

uninterruptibleMask :: ((forall a. EmbedC m a -> EmbedC m a) -> EmbedC m b) -> EmbedC m b #

generalBracket :: EmbedC m a -> (a -> ExitCase b -> EmbedC m c) -> (a -> EmbedC m b) -> EmbedC m (b, c) #

MonadMask m => MonadMask (RunMC m) Source # 
Instance details

Defined in Control.Effect.Embed

Methods

mask :: ((forall a. RunMC m a -> RunMC m a) -> RunMC m b) -> RunMC m b #

uninterruptibleMask :: ((forall a. RunMC m a -> RunMC m a) -> RunMC m b) -> RunMC m b #

generalBracket :: RunMC m a -> (a -> ExitCase b -> RunMC m c) -> (a -> RunMC m b) -> RunMC m (b, c) #

(Monoid o, MonadMask m) => MonadMask (WriterLazyC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. WriterLazyC o m a -> WriterLazyC o m a) -> WriterLazyC o m b) -> WriterLazyC o m b #

uninterruptibleMask :: ((forall a. WriterLazyC o m a -> WriterLazyC o m a) -> WriterLazyC o m b) -> WriterLazyC o m b #

generalBracket :: WriterLazyC o m a -> (a -> ExitCase b -> WriterLazyC o m c) -> (a -> WriterLazyC o m b) -> WriterLazyC o m (b, c) #

(Monoid o, MonadMask m) => MonadMask (ListenLazyC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. ListenLazyC o m a -> ListenLazyC o m a) -> ListenLazyC o m b) -> ListenLazyC o m b #

uninterruptibleMask :: ((forall a. ListenLazyC o m a -> ListenLazyC o m a) -> ListenLazyC o m b) -> ListenLazyC o m b #

generalBracket :: ListenLazyC o m a -> (a -> ExitCase b -> ListenLazyC o m c) -> (a -> ListenLazyC o m b) -> ListenLazyC o m (b, c) #

(Monoid o, MonadMask m) => MonadMask (TellLazyC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. TellLazyC o m a -> TellLazyC o m a) -> TellLazyC o m b) -> TellLazyC o m b #

uninterruptibleMask :: ((forall a. TellLazyC o m a -> TellLazyC o m a) -> TellLazyC o m b) -> TellLazyC o m b #

generalBracket :: TellLazyC o m a -> (a -> ExitCase b -> TellLazyC o m c) -> (a -> TellLazyC o m b) -> TellLazyC o m (b, c) #

(Monoid o, MonadMask m) => MonadMask (WriterC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. WriterC o m a -> WriterC o m a) -> WriterC o m b) -> WriterC o m b #

uninterruptibleMask :: ((forall a. WriterC o m a -> WriterC o m a) -> WriterC o m b) -> WriterC o m b #

generalBracket :: WriterC o m a -> (a -> ExitCase b -> WriterC o m c) -> (a -> WriterC o m b) -> WriterC o m (b, c) #

(Monoid o, MonadMask m) => MonadMask (ListenC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. ListenC o m a -> ListenC o m a) -> ListenC o m b) -> ListenC o m b #

uninterruptibleMask :: ((forall a. ListenC o m a -> ListenC o m a) -> ListenC o m b) -> ListenC o m b #

generalBracket :: ListenC o m a -> (a -> ExitCase b -> ListenC o m c) -> (a -> ListenC o m b) -> ListenC o m (b, c) #

(Monoid o, MonadMask m) => MonadMask (TellC o m) Source # 
Instance details

Defined in Control.Effect.Internal.Writer

Methods

mask :: ((forall a. TellC o m a -> TellC o m a) -> TellC o m b) -> TellC o m b #

uninterruptibleMask :: ((forall a. TellC o m a -> TellC o m a) -> TellC o m b) -> TellC o m b #

generalBracket :: TellC o m a -> (a -> ExitCase b -> TellC o m c) -> (a -> TellC o m b) -> TellC o m (b, c) #

MonadMask m => MonadMask (UnliftC m) Source # 
Instance details

Defined in Control.Effect.Internal.Unlift

Methods

mask :: ((forall a. UnliftC m a -> UnliftC m a) -> UnliftC m b) -> UnliftC m b #

uninterruptibleMask :: ((forall a. UnliftC m a -> UnliftC m a) -> UnliftC m b) -> UnliftC m b #

generalBracket :: UnliftC m a -> (a -> ExitCase b -> UnliftC m c) -> (a -> UnliftC m b) -> UnliftC m (b, c) #

MonadMask m => MonadMask (StateLazyC s m) Source # 
Instance details

Defined in Control.Effect.Internal.State

Methods

mask :: ((forall a. StateLazyC s m a -> StateLazyC s m a) -> StateLazyC s m b) -> StateLazyC s m b #

uninterruptibleMask :: ((forall a. StateLazyC s m a -> StateLazyC s m a) -> StateLazyC s m b) -> StateLazyC s m b #

generalBracket :: StateLazyC s m a -> (a -> ExitCase b -> StateLazyC s m c) -> (a -> StateLazyC s m b) -> StateLazyC s m (b, c) #

MonadMask m => MonadMask (StateC s m) Source # 
Instance details

Defined in Control.Effect.Internal.State

Methods

mask :: ((forall a. StateC s m a -> StateC s m a) -> StateC s m b) -> StateC s m b #

uninterruptibleMask :: ((forall a. StateC s m a -> StateC s m a) -> StateC s m b) -> StateC s m b #

generalBracket :: StateC s m a -> (a -> ExitCase b -> StateC s m c) -> (a -> StateC s m b) -> StateC s m (b, c) #

MonadMask m => MonadMask (HoistC m) Source # 
Instance details

Defined in Control.Effect.Internal.Regional

Methods

mask :: ((forall a. HoistC m a -> HoistC m a) -> HoistC m b) -> HoistC m b #

uninterruptibleMask :: ((forall a. HoistC m a -> HoistC m a) -> HoistC m b) -> HoistC m b #

generalBracket :: HoistC m a -> (a -> ExitCase b -> HoistC m c) -> (a -> HoistC m b) -> HoistC m (b, c) #

MonadMask m => MonadMask (ReaderC i m) Source # 
Instance details

Defined in Control.Effect.Internal.Reader

Methods

mask :: ((forall a. ReaderC i m a -> ReaderC i m a) -> ReaderC i m b) -> ReaderC i m b #

uninterruptibleMask :: ((forall a. ReaderC i m a -> ReaderC i m a) -> ReaderC i m b) -> ReaderC i m b #

generalBracket :: ReaderC i m a -> (a -> ExitCase b -> ReaderC i m c) -> (a -> ReaderC i m b) -> ReaderC i m (b, c) #

MonadMask m => MonadMask (HoistOptionC m) Source # 
Instance details

Defined in Control.Effect.Internal.Optional

Methods

mask :: ((forall a. HoistOptionC m a -> HoistOptionC m a) -> HoistOptionC m b) -> HoistOptionC m b #

uninterruptibleMask :: ((forall a. HoistOptionC m a -> HoistOptionC m a) -> HoistOptionC m b) -> HoistOptionC m b #

generalBracket :: HoistOptionC m a -> (a -> ExitCase b -> HoistOptionC m c) -> (a -> HoistOptionC m b) -> HoistOptionC m (b, c) #

MonadMask m => MonadMask (UnwrapTopC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Newtype

Methods

mask :: ((forall a. UnwrapTopC e m a -> UnwrapTopC e m a) -> UnwrapTopC e m b) -> UnwrapTopC e m b #

uninterruptibleMask :: ((forall a. UnwrapTopC e m a -> UnwrapTopC e m a) -> UnwrapTopC e m b) -> UnwrapTopC e m b #

generalBracket :: UnwrapTopC e m a -> (a -> ExitCase b -> UnwrapTopC e m c) -> (a -> UnwrapTopC e m b) -> UnwrapTopC e m (b, c) #

MonadMask m => MonadMask (UnwrapC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Newtype

Methods

mask :: ((forall a. UnwrapC e m a -> UnwrapC e m a) -> UnwrapC e m b) -> UnwrapC e m b #

uninterruptibleMask :: ((forall a. UnwrapC e m a -> UnwrapC e m a) -> UnwrapC e m b) -> UnwrapC e m b #

generalBracket :: UnwrapC e m a -> (a -> ExitCase b -> UnwrapC e m c) -> (a -> UnwrapC e m b) -> UnwrapC e m (b, c) #

MonadMask m => MonadMask (ErrorToIOSimpleC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. ErrorToIOSimpleC e m a -> ErrorToIOSimpleC e m a) -> ErrorToIOSimpleC e m b) -> ErrorToIOSimpleC e m b #

uninterruptibleMask :: ((forall a. ErrorToIOSimpleC e m a -> ErrorToIOSimpleC e m a) -> ErrorToIOSimpleC e m b) -> ErrorToIOSimpleC e m b #

generalBracket :: ErrorToIOSimpleC e m a -> (a -> ExitCase b -> ErrorToIOSimpleC e m c) -> (a -> ErrorToIOSimpleC e m b) -> ErrorToIOSimpleC e m (b, c) #

MonadMask m => MonadMask (InterpretErrorSimpleC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

MonadMask m => MonadMask (ErrorToIOAsExcC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. ErrorToIOAsExcC e m a -> ErrorToIOAsExcC e m a) -> ErrorToIOAsExcC e m b) -> ErrorToIOAsExcC e m b #

uninterruptibleMask :: ((forall a. ErrorToIOAsExcC e m a -> ErrorToIOAsExcC e m a) -> ErrorToIOAsExcC e m b) -> ErrorToIOAsExcC e m b #

generalBracket :: ErrorToIOAsExcC e m a -> (a -> ExitCase b -> ErrorToIOAsExcC e m c) -> (a -> ErrorToIOAsExcC e m b) -> ErrorToIOAsExcC e m (b, c) #

MonadMask m => MonadMask (ErrorToErrorIOAsExcC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

MonadMask m => MonadMask (ErrorC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. ErrorC e m a -> ErrorC e m a) -> ErrorC e m b) -> ErrorC e m b #

uninterruptibleMask :: ((forall a. ErrorC e m a -> ErrorC e m a) -> ErrorC e m b) -> ErrorC e m b #

generalBracket :: ErrorC e m a -> (a -> ExitCase b -> ErrorC e m c) -> (a -> ErrorC e m b) -> ErrorC e m (b, c) #

MonadMask m => MonadMask (ThrowC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. ThrowC e m a -> ThrowC e m a) -> ThrowC e m b) -> ThrowC e m b #

uninterruptibleMask :: ((forall a. ThrowC e m a -> ThrowC e m a) -> ThrowC e m b) -> ThrowC e m b #

generalBracket :: ThrowC e m a -> (a -> ExitCase b -> ThrowC e m c) -> (a -> ThrowC e m b) -> ThrowC e m (b, c) #

MonadMask m => MonadMask (SafeErrorToErrorIOSimpleC exc m) Source # 
Instance details

Defined in Control.Effect.Internal.Exceptional

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) #

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) #

MonadMask m => MonadMask (BaseControlC m) Source # 
Instance details

Defined in Control.Effect.Internal.BaseControl

Methods

mask :: ((forall a. BaseControlC m a -> BaseControlC m a) -> BaseControlC m b) -> BaseControlC m b #

uninterruptibleMask :: ((forall a. BaseControlC m a -> BaseControlC m a) -> BaseControlC m b) -> BaseControlC m b #

generalBracket :: BaseControlC m a -> (a -> ExitCase b -> BaseControlC m c) -> (a -> BaseControlC m b) -> BaseControlC m (b, c) #

MonadMask m => MonadMask (FreshEnumC uniq m) Source # 
Instance details

Defined in Control.Effect.Fresh

Methods

mask :: ((forall a. FreshEnumC uniq m a -> FreshEnumC uniq m a) -> FreshEnumC uniq m b) -> FreshEnumC uniq m b #

uninterruptibleMask :: ((forall a. FreshEnumC uniq m a -> FreshEnumC uniq m a) -> FreshEnumC uniq m b) -> FreshEnumC uniq m b #

generalBracket :: FreshEnumC uniq m a -> (a -> ExitCase b -> FreshEnumC uniq m c) -> (a -> FreshEnumC uniq m b) -> FreshEnumC uniq m (b, c) #

MonadMask m => MonadMask (WriterTVarC o m) Source # 
Instance details

Defined in Control.Effect.Writer

Methods

mask :: ((forall a. WriterTVarC o m a -> WriterTVarC o m a) -> WriterTVarC o m b) -> WriterTVarC o m b #

uninterruptibleMask :: ((forall a. WriterTVarC o m a -> WriterTVarC o m a) -> WriterTVarC o m b) -> WriterTVarC o m b #

generalBracket :: WriterTVarC o m a -> (a -> ExitCase b -> WriterTVarC o m c) -> (a -> WriterTVarC o m b) -> WriterTVarC o m (b, c) #

MonadMask m => MonadMask (ListenTVarC o m) Source # 
Instance details

Defined in Control.Effect.Writer

Methods

mask :: ((forall a. ListenTVarC o m a -> ListenTVarC o m a) -> ListenTVarC o m b) -> ListenTVarC o m b #

uninterruptibleMask :: ((forall a. ListenTVarC o m a -> ListenTVarC o m a) -> ListenTVarC o m b) -> ListenTVarC o m b #

generalBracket :: ListenTVarC o m a -> (a -> ExitCase b -> ListenTVarC o m c) -> (a -> ListenTVarC o m b) -> ListenTVarC o m (b, c) #

MonadMask m => MonadMask (WriterToBracketC o m) Source # 
Instance details

Defined in Control.Effect.Writer

Methods

mask :: ((forall a. WriterToBracketC o m a -> WriterToBracketC o m a) -> WriterToBracketC o m b) -> WriterToBracketC o m b #

uninterruptibleMask :: ((forall a. WriterToBracketC o m a -> WriterToBracketC o m a) -> WriterToBracketC o m b) -> WriterToBracketC o m b #

generalBracket :: WriterToBracketC o m a -> (a -> ExitCase b -> WriterToBracketC o m c) -> (a -> WriterToBracketC o m b) -> WriterToBracketC o m (b, c) #

MonadMask m => MonadMask (WriterIntoEndoWriterC o m) Source # 
Instance details

Defined in Control.Effect.Writer

MonadMask m => MonadMask (ListenIntoEndoListenC o m) Source # 
Instance details

Defined in Control.Effect.Writer

MonadMask m => MonadMask (TellListLazyC o m) Source # 
Instance details

Defined in Control.Effect.Writer

Methods

mask :: ((forall a. TellListLazyC o m a -> TellListLazyC o m a) -> TellListLazyC o m b) -> TellListLazyC o m b #

uninterruptibleMask :: ((forall a. TellListLazyC o m a -> TellListLazyC o m a) -> TellListLazyC o m b) -> TellListLazyC o m b #

generalBracket :: TellListLazyC o m a -> (a -> ExitCase b -> TellListLazyC o m c) -> (a -> TellListLazyC o m b) -> TellListLazyC o m (b, c) #

MonadMask m => MonadMask (TellListC o m) Source # 
Instance details

Defined in Control.Effect.Writer

Methods

mask :: ((forall a. TellListC o m a -> TellListC o m a) -> TellListC o m b) -> TellListC o m b #

uninterruptibleMask :: ((forall a. TellListC o m a -> TellListC o m a) -> TellListC o m b) -> TellListC o m b #

generalBracket :: TellListC o m a -> (a -> ExitCase b -> TellListC o m c) -> (a -> TellListC o m b) -> TellListC o m (b, c) #

MonadMask m => MonadMask (InterceptRC e m) Source # 
Instance details

Defined in Control.Effect.Internal.Intercept

Methods

mask :: ((forall a. InterceptRC e m a -> InterceptRC e m a) -> InterceptRC e m b) -> InterceptRC e m b #

uninterruptibleMask :: ((forall a. InterceptRC e m a -> InterceptRC e m a) -> InterceptRC e m b) -> InterceptRC e m b #

generalBracket :: InterceptRC e m a -> (a -> ExitCase b -> InterceptRC e m c) -> (a -> InterceptRC e m b) -> InterceptRC e m (b, c) #

MonadMask m => MonadMask (InterpretFailC h m) Source # 
Instance details

Defined in Control.Effect.Fail

Methods

mask :: ((forall a. InterpretFailC h m a -> InterpretFailC h m a) -> InterpretFailC h m b) -> InterpretFailC h m b #

uninterruptibleMask :: ((forall a. InterpretFailC h m a -> InterpretFailC h m a) -> InterpretFailC h m b) -> InterpretFailC h m b #

generalBracket :: InterpretFailC h m a -> (a -> ExitCase b -> InterpretFailC h m c) -> (a -> InterpretFailC h m b) -> InterpretFailC h m (b, c) #

MonadMask m => MonadMask (InterpretAltC h m) Source # 
Instance details

Defined in Control.Effect.Alt

Methods

mask :: ((forall a. InterpretAltC h m a -> InterpretAltC h m a) -> InterpretAltC h m b) -> InterpretAltC h m b #

uninterruptibleMask :: ((forall a. InterpretAltC h m a -> InterpretAltC h m a) -> InterpretAltC h m b) -> InterpretAltC h m b #

generalBracket :: InterpretAltC h m a -> (a -> ExitCase b -> InterpretAltC h m c) -> (a -> InterpretAltC h m b) -> InterpretAltC h m (b, c) #

MonadMask m => MonadMask (SubsumeC e m) Source # 
Instance details

Defined in Control.Effect.Internal

Methods

mask :: ((forall a. SubsumeC e m a -> SubsumeC e m a) -> SubsumeC e m b) -> SubsumeC e m b #

uninterruptibleMask :: ((forall a. SubsumeC e m a -> SubsumeC e m a) -> SubsumeC e m b) -> SubsumeC e m b #

generalBracket :: SubsumeC e m a -> (a -> ExitCase b -> SubsumeC e m c) -> (a -> SubsumeC e m b) -> SubsumeC e m (b, c) #

MonadMask m => MonadMask (IntroC top new m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Intro

Methods

mask :: ((forall a. IntroC top new m a -> IntroC top new m a) -> IntroC top new m b) -> IntroC top new m b #

uninterruptibleMask :: ((forall a. IntroC top new m a -> IntroC top new m a) -> IntroC top new m b) -> IntroC top new m b #

generalBracket :: IntroC top new m a -> (a -> ExitCase b -> IntroC top new m c) -> (a -> IntroC top new m b) -> IntroC top new m (b, c) #

MonadMask m => MonadMask (ReinterpretSimpleC e new m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

Methods

mask :: ((forall a. ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m b) -> ReinterpretSimpleC e new m b #

uninterruptibleMask :: ((forall a. ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m b) -> ReinterpretSimpleC e new m b #

generalBracket :: ReinterpretSimpleC e new m a -> (a -> ExitCase b -> ReinterpretSimpleC e new m c) -> (a -> ReinterpretSimpleC e new m b) -> ReinterpretSimpleC e new m (b, c) #

MonadMask m => MonadMask (InterpretC h e m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

Methods

mask :: ((forall a. InterpretC h e m a -> InterpretC h e m a) -> InterpretC h e m b) -> InterpretC h e m b #

uninterruptibleMask :: ((forall a. InterpretC h e m a -> InterpretC h e m a) -> InterpretC h e m b) -> InterpretC h e m b #

generalBracket :: InterpretC h e m a -> (a -> ExitCase b -> InterpretC h e m c) -> (a -> InterpretC h e m b) -> InterpretC h e m (b, c) #

MonadMask m => MonadMask (InterpretPrimC s e m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

Methods

mask :: ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a) -> InterpretPrimC s e m b) -> InterpretPrimC s e m b #

uninterruptibleMask :: ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a) -> InterpretPrimC s e m b) -> InterpretPrimC s e m b #

generalBracket :: InterpretPrimC s e m a -> (a -> ExitCase b -> InterpretPrimC s e m c) -> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m (b, c) #

MonadMask m => MonadMask (UnionC l m) Source # 
Instance details

Defined in Control.Effect.Union

Methods

mask :: ((forall a. UnionC l m a -> UnionC l m a) -> UnionC l m b) -> UnionC l m b #

uninterruptibleMask :: ((forall a. UnionC l m a -> UnionC l m a) -> UnionC l m b) -> UnionC l m b #

generalBracket :: UnionC l m a -> (a -> ExitCase b -> UnionC l m c) -> (a -> UnionC l m b) -> UnionC l m (b, c) #

MonadMask m => MonadMask (WrapC e e' m) Source # 
Instance details

Defined in Control.Effect.Internal.Newtype

Methods

mask :: ((forall a. WrapC e e' m a -> WrapC e e' m a) -> WrapC e e' m b) -> WrapC e e' m b #

uninterruptibleMask :: ((forall a. WrapC e e' m a -> WrapC e e' m a) -> WrapC e e' m b) -> WrapC e e' m b #

generalBracket :: WrapC e e' m a -> (a -> ExitCase b -> WrapC e e' m c) -> (a -> WrapC e e' m b) -> WrapC e e' m (b, c) #

(MonadMask m, Monoid w) => MonadMask (RWST r w s m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #

(MonadMask m, Monoid w) => MonadMask (RWST r w s m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #

MonadMask (t (u m)) => MonadMask (ComposeT t u m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Compose

Methods

mask :: ((forall a. ComposeT t u m a -> ComposeT t u m a) -> ComposeT t u m b) -> ComposeT t u m b #

uninterruptibleMask :: ((forall a. ComposeT t u m a -> ComposeT t u m a) -> ComposeT t u m b) -> ComposeT t u m b #

generalBracket :: ComposeT t u m a -> (a -> ExitCase b -> ComposeT t u m c) -> (a -> ComposeT t u m b) -> ComposeT t u m (b, c) #

(Reifies s (ReifiedEffAlgebra Bracket m), Monad m) => MonadMask (ViaAlg s Bracket m) Source # 
Instance details

Defined in Control.Effect.Type.Bracket

Methods

mask :: ((forall a. ViaAlg s Bracket m a -> ViaAlg s Bracket m a) -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m b #

uninterruptibleMask :: ((forall a. ViaAlg s Bracket m a -> ViaAlg s Bracket m a) -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m b #

generalBracket :: ViaAlg s Bracket m a -> (a -> ExitCase b -> ViaAlg s Bracket m c) -> (a -> ViaAlg s Bracket m b) -> ViaAlg s Bracket m (b, c) #

(Reifies s (ReifiedEffAlgebra Mask m), Monad m) => MonadMask (ViaAlg s Mask m) Source # 
Instance details

Defined in Control.Effect.Type.Mask

Methods

mask :: ((forall a. ViaAlg s Mask m a -> ViaAlg s Mask m a) -> ViaAlg s Mask m b) -> ViaAlg s Mask m b #

uninterruptibleMask :: ((forall a. ViaAlg s Mask m a -> ViaAlg s Mask m a) -> ViaAlg s Mask m b) -> ViaAlg s Mask m b #

generalBracket :: ViaAlg s Mask m a -> (a -> ExitCase b -> ViaAlg s Mask m c) -> (a -> ViaAlg s Mask m b) -> ViaAlg s Mask m (b, c) #

MonadMask m => MonadMask (ReinterpretC h e new m) Source # 
Instance details

Defined in Control.Effect.Carrier.Internal.Interpret

Methods

mask :: ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a) -> ReinterpretC h e new m b) -> ReinterpretC h e new m b #

uninterruptibleMask :: ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a) -> ReinterpretC h e new m b) -> ReinterpretC h e new m b #

generalBracket :: ReinterpretC h e new m a -> (a -> ExitCase b -> ReinterpretC h e new m c) -> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m (b, c) #

MonadMask m => MonadMask (UnionizeC b m) Source # 
Instance details

Defined in Control.Effect.Union

Methods

mask :: ((forall a. UnionizeC b m a -> UnionizeC b m a) -> UnionizeC b m b0) -> UnionizeC b m b0 #

uninterruptibleMask :: ((forall a. UnionizeC b m a -> UnionizeC b m a) -> UnionizeC b m b0) -> UnionizeC b m b0 #

generalBracket :: UnionizeC b m a -> (a -> ExitCase b0 -> UnionizeC b m c) -> (a -> UnionizeC b m b0) -> UnionizeC b m (b0, c) #

MonadMask m => MonadMask (UnionizeHeadC b m) Source # 
Instance details

Defined in Control.Effect.Union

Methods

mask :: ((forall a. UnionizeHeadC b m a -> UnionizeHeadC b m a) -> UnionizeHeadC b m b0) -> UnionizeHeadC b m b0 #

uninterruptibleMask :: ((forall a. UnionizeHeadC b m a -> UnionizeHeadC b m a) -> UnionizeHeadC b m b0) -> UnionizeHeadC b m b0 #

generalBracket :: UnionizeHeadC b m a -> (a -> ExitCase b0 -> UnionizeHeadC b m c) -> (a -> UnionizeHeadC b m b0) -> UnionizeHeadC b m (b0, c) #

MonadMask m => MonadMask (ErrorToIOC' s s' e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. ErrorToIOC' s s' e m a -> ErrorToIOC' s s' e m a) -> ErrorToIOC' s s' e m b) -> ErrorToIOC' s s' e m b #

uninterruptibleMask :: ((forall a. ErrorToIOC' s s' e m a -> ErrorToIOC' s s' e m a) -> ErrorToIOC' s s' e m b) -> ErrorToIOC' s s' e m b #

generalBracket :: ErrorToIOC' s s' e m a -> (a -> ExitCase b -> ErrorToIOC' s s' e m c) -> (a -> ErrorToIOC' s s' e m b) -> ErrorToIOC' s s' e m (b, c) #

MonadMask m => MonadMask (InterpretErrorC' s s' e m) Source # 
Instance details

Defined in Control.Effect.Internal.Error

Methods

mask :: ((forall a. InterpretErrorC' s s' e m a -> InterpretErrorC' s s' e m a) -> InterpretErrorC' s s' e m b) -> InterpretErrorC' s s' e m b #

uninterruptibleMask :: ((forall a. InterpretErrorC' s s' e m a -> InterpretErrorC' s s' e m a) -> InterpretErrorC' s s' e m b) -> InterpretErrorC' s s' e m b #

generalBracket :: InterpretErrorC' s s' e m a -> (a -> ExitCase b -> InterpretErrorC' s s' e m c) -> (a -> InterpretErrorC' s s' e m b) -> InterpretErrorC' s s' e m (b, c) #

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) #

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) #

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) #

MonadMask m => MonadMask (GainBaseControlC b z m) Source # 
Instance details

Defined in Control.Effect.BaseControl

Methods

mask :: ((forall a. GainBaseControlC b z m a -> GainBaseControlC b z m a) -> GainBaseControlC b z m b0) -> GainBaseControlC b z m b0 #

uninterruptibleMask :: ((forall a. GainBaseControlC b z m a -> GainBaseControlC b z m a) -> GainBaseControlC b z m b0) -> GainBaseControlC b z m b0 #

generalBracket :: GainBaseControlC b z m a -> (a -> ExitCase b0 -> GainBaseControlC b z m c) -> (a -> GainBaseControlC b z m b0) -> GainBaseControlC b z m (b0, c) #

Carriers

type IgnoreBracketC = InterpretC IgnoreBracketH Bracket Source #