Control.Effect.BaseControl

Effects

data BaseControl b m a

A helper primitive effect that allows for lowering computations to a base monad.

Helper primitive effects are effects that allow you to avoid interpreting one of your own effects as a primitive if the power needed from direct access to the underlying monad can instead be provided by the relevant helper primitive effect. The reason why you'd want to do this is that helper primitive effects already have ThreadsEff instances defined for them; so you don't have to define any for your own effect.

The helper primitive effects offered in this library are -- in order of ascending power -- Regional, Optional, BaseControl and Unlift.

BaseControl 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 a ThreadsEff t (BaseControl b) instance (if possible). threadBaseControlViaClass can help you with that.

The following threading constraints accept BaseControl:

• ReaderThreads
• StateThreads
• StateLazyThreads
• ErrorThreads
• WriterThreads
• WriterLazyThreads

Instances

Carrier m => PrimHandler BaseControlH (BaseControl m) m

Defined in Control.Effect.Internal.BaseControl

Methods

effPrimHandler :: EffPrimHandler (BaseControl m) m

ThreadsEff (ExceptT e) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (ExceptT e m) a -> ExceptT e m a

Monoid w => ThreadsEff (WriterT w) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (WriterT w m) a -> WriterT w m a

ThreadsEff (StateT s) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (StateT s m) a -> StateT s m a

ThreadsEff (ReaderT i) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (ReaderT i m) a -> ReaderT i m a

ThreadsEff (StateT s) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (StateT s m) a -> StateT s m a

Monoid w => ThreadsEff (WriterT w) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (WriterT w m) a -> WriterT w m a

Monoid w => ThreadsEff (WriterT w) (BaseControl b)

Defined in Control.Effect.Type.Internal.BaseControl

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (WriterT w m) a -> WriterT w m a

Actions

withLowerToBase :: forall b m a. Eff (BaseControl b) m => (forall f. (forall x. m x -> b (f x)) -> b (f a)) -> m a

Gain access to a function that allows for lowering m to the base monad b.

This is less versatile, but easier to use than gainBaseControl.

gainBaseControl :: forall b m a. Eff (BaseControl b) m => (forall z. (MonadBaseControl b z, Coercible z m) => GainBaseControlC b z m a) -> m a

Locally gain access to a MonadBaseControl b instance within a region.

You'll need to use lift if you want to use the MonadBaseControl instance with computations outside of the region. This is common with effect handlers. For example:

import System.IO (FilePath, IOMode, Handle)
import qualified System.IO as SysIO

data WithFile m a where
  WithFile :: FilePath -> IOMode -> (Handle -> m a) -> WithFile m a

runWithFile :: Eff (BaseControl IO) m => SimpleInterpreterFor WithFile m
runWithFile = interpretSimple $ \case
  WithFile fp mode c -> gainBaseControl $ control $ \lower ->
    SysIO.withFile fp mode (\hdl -> lower (lift (c hdl)))

Interpretations

runBaseControl :: Carrier m => BaseControlC m a -> m a

Run a BaseControl m effect, where the base m is the current monad.

Derivs (BaseControlC m) = BaseControl m ': Derivs m

Prims  (BaseControlC m) = BaseControl m ': Prims m

baseControlToFinal :: (MonadBaseControl b m, Carrier m) => BaseControlToFinalC b m a -> m a

Run a BaseControl b effect, where the base b is the final base monad.

Derivs (BaseControlToFinalC b m) = BaseControl b ': Derivs m

Prims  (BaseControlToFinalC b m) = BaseControl b ': Prims m

MonadBaseControl

class MonadBase b m => MonadBaseControl (b :: Type -> Type) (m :: Type -> Type) | m -> b where

Writing instances

The usual way to write a MonadBaseControl instance for a transformer stack over a base monad B is to write an instance MonadBaseControl B B for the base monad, and MonadTransControl T instances for every transformer T. Instances for MonadBaseControl are then simply implemented using ComposeSt, defaultLiftBaseWith, defaultRestoreM.

Associated Types

type StM (m :: Type -> Type) a

Monadic state that m adds to the base monad b.

For all base (non-transformed) monads, StM m a ~ a:

StM IO         a ~ a
StM Maybe      a ~ a
StM (Either e) a ~ a
StM []         a ~ a
StM ((->) r)   a ~ a
StM Identity   a ~ a
StM STM        a ~ a
StM (ST s)     a ~ a

If m is a transformed monad, m ~ t b, StM is the monadic state of the transformer t (given by its StT from MonadTransControl). For a transformer stack, StM is defined recursively:

StM (IdentityT  m) a ~ ComposeSt IdentityT m a ~ StM m a
StM (MaybeT     m) a ~ ComposeSt MaybeT    m a ~ StM m (Maybe a)
StM (ErrorT e   m) a ~ ComposeSt ErrorT    m a ~ Error e => StM m (Either e a)
StM (ExceptT e  m) a ~ ComposeSt ExceptT   m a ~ StM m (Either e a)
StM (ListT      m) a ~ ComposeSt ListT     m a ~ StM m [a]
StM (ReaderT r  m) a ~ ComposeSt ReaderT   m a ~ StM m a
StM (StateT s   m) a ~ ComposeSt StateT    m a ~ StM m (a, s)
StM (WriterT w  m) a ~ ComposeSt WriterT   m a ~ Monoid w => StM m (a, w)
StM (RWST r w s m) a ~ ComposeSt RWST      m a ~ Monoid w => StM m (a, s, w)

Methods

liftBaseWith :: (RunInBase m b -> b a) -> m a

liftBaseWith is similar to liftIO and liftBase in that it lifts a base computation to the constructed monad.

Instances should satisfy similar laws as the MonadIO and MonadBase laws:

liftBaseWith (\_ -> return a) = return a

liftBaseWith (\_ -> m >>= f)  =  liftBaseWith (\_ -> m) >>= (\a -> liftBaseWith (\_ -> f a))

As Li-yao Xia explains, parametricity guarantees that

f $ liftBaseWith q = liftBaseWith $ runInBase -> f $ q runInBase

The difference with liftBase is that before lifting the base computation liftBaseWith captures the state of m. It then provides the base computation with a RunInBase function that allows running m computations in the base monad on the captured state:

withFileLifted :: MonadBaseControl IO m => FilePath -> IOMode -> (Handle -> m a) -> m a
withFileLifted file mode action = liftBaseWith (\runInBase -> withFile file mode (runInBase . action)) >>= restoreM
                             -- = control $ \runInBase -> withFile file mode (runInBase . action)
                             -- = liftBaseOp (withFile file mode) action

liftBaseWith is usually not implemented directly, but using defaultLiftBaseWith.

restoreM :: StM m a -> m a

Construct a m computation from the monadic state of m that is returned from a RunInBase function.

Instances should satisfy:

liftBaseWith (\runInBase -> runInBase m) >>= restoreM = m

restoreM is usually not implemented directly, but using defaultRestoreM.

Instances

MonadBaseControl [] []

Defined in Control.Monad.Trans.Control

Associated Types

type StM [] a

Methods

liftBaseWith :: (RunInBase [] [] -> [a]) -> [a]

restoreM :: StM [] a -> [a]

MonadBaseControl Maybe Maybe

Defined in Control.Monad.Trans.Control

Associated Types

type StM Maybe a

Methods

liftBaseWith :: (RunInBase Maybe Maybe -> Maybe a) -> Maybe a

restoreM :: StM Maybe a -> Maybe a

MonadBaseControl IO IO

Defined in Control.Monad.Trans.Control

Associated Types

type StM IO a

Methods

liftBaseWith :: (RunInBase IO IO -> IO a) -> IO a

restoreM :: StM IO a -> IO a

MonadBaseControl Identity Identity

Defined in Control.Monad.Trans.Control

Associated Types

type StM Identity a

Methods

liftBaseWith :: (RunInBase Identity Identity -> Identity a) -> Identity a

restoreM :: StM Identity a -> Identity a

MonadBaseControl STM STM

Defined in Control.Monad.Trans.Control

Associated Types

type StM STM a

Methods

liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a

restoreM :: StM STM a -> STM a

MonadBaseControl b m => MonadBaseControl b (MaybeT m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (MaybeT m) a

Methods

liftBaseWith :: (RunInBase (MaybeT m) b -> b a) -> MaybeT m a

restoreM :: StM (MaybeT m) a -> MaybeT m a

MonadBaseControl b m => MonadBaseControl b (ListT m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ListT m) a

Methods

liftBaseWith :: (RunInBase (ListT m) b -> b a) -> ListT m a

restoreM :: StM (ListT m) a -> ListT m a

MonadBaseControl b m => MonadBaseControl b (ErrorIOToIOC m)

Defined in Control.Effect.Internal.ErrorIO

Associated Types

type StM (ErrorIOToIOC m) a

Methods

liftBaseWith :: (RunInBase (ErrorIOToIOC m) b -> b a) -> ErrorIOToIOC m a

restoreM :: StM (ErrorIOToIOC m) a -> ErrorIOToIOC m a

MonadBaseControl b m => MonadBaseControl b (ConcToIOC m)

Defined in Control.Effect.Internal.Conc

Associated Types

type StM (ConcToIOC m) a

Methods

liftBaseWith :: (RunInBase (ConcToIOC m) b -> b a) -> ConcToIOC m a

restoreM :: StM (ConcToIOC m) a -> ConcToIOC m a

MonadBaseControl b m => MonadBaseControl b (TraceListC m)

Defined in Control.Effect.Trace

Associated Types

type StM (TraceListC m) a

Methods

liftBaseWith :: (RunInBase (TraceListC m) b -> b a) -> TraceListC m a

restoreM :: StM (TraceListC m) a -> TraceListC m a

MonadBaseControl b m => MonadBaseControl b (InterpretFailSimpleC m)

Defined in Control.Effect.Fail

Associated Types

type StM (InterpretFailSimpleC m) a

Methods

liftBaseWith :: (RunInBase (InterpretFailSimpleC m) b -> b a) -> InterpretFailSimpleC m a

restoreM :: StM (InterpretFailSimpleC m) a -> InterpretFailSimpleC m a

MonadBaseControl b m => MonadBaseControl b (FailC m)

Defined in Control.Effect.Fail

Associated Types

type StM (FailC m) a

Methods

liftBaseWith :: (RunInBase (FailC m) b -> b a) -> FailC m a

restoreM :: StM (FailC m) a -> FailC m a

MonadBaseControl b m => MonadBaseControl b (AltMaybeC m)

Defined in Control.Effect.Alt

Associated Types

type StM (AltMaybeC m) a

Methods

liftBaseWith :: (RunInBase (AltMaybeC m) b -> b a) -> AltMaybeC m a

restoreM :: StM (AltMaybeC m) a -> AltMaybeC m a

MonadBaseControl b m => MonadBaseControl b (InterpretAltSimpleC m)

Defined in Control.Effect.Alt

Associated Types

type StM (InterpretAltSimpleC m) a

Methods

liftBaseWith :: (RunInBase (InterpretAltSimpleC m) b -> b a) -> InterpretAltSimpleC m a

restoreM :: StM (InterpretAltSimpleC m) a -> InterpretAltSimpleC m a

Monad m => MonadBaseControl m (Itself m)

Defined in Control.Effect.Internal.Itself

Associated Types

type StM (Itself m) a

Methods

liftBaseWith :: (RunInBase (Itself m) m -> m a) -> Itself m a

restoreM :: StM (Itself m) a -> Itself m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (WriterT w m) a

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a

restoreM :: StM (WriterT w m) a -> WriterT w m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (WriterT w m) a

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a

restoreM :: StM (WriterT w m) a -> WriterT w m a

MonadBaseControl b m => MonadBaseControl b (StateT s m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (StateT s m) a

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a

restoreM :: StM (StateT s m) a -> StateT s m a

MonadBaseControl b m => MonadBaseControl b (StateT s m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (StateT s m) a

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a

restoreM :: StM (StateT s m) a -> StateT s m a

MonadBaseControl b m => MonadBaseControl b (ReaderT r m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ReaderT r m) a

Methods

liftBaseWith :: (RunInBase (ReaderT r m) b -> b a) -> ReaderT r m a

restoreM :: StM (ReaderT r m) a -> ReaderT r m a

MonadBaseControl b m => MonadBaseControl b (IdentityT m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (IdentityT m) a

Methods

liftBaseWith :: (RunInBase (IdentityT m) b -> b a) -> IdentityT m a

restoreM :: StM (IdentityT m) a -> IdentityT m a

MonadBaseControl b m => MonadBaseControl b (ExceptT e m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ExceptT e m) a

Methods

liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a

restoreM :: StM (ExceptT e m) a -> ExceptT e m a

(Error e, MonadBaseControl b m) => MonadBaseControl b (ErrorT e m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ErrorT e m) a

Methods

liftBaseWith :: (RunInBase (ErrorT e m) b -> b a) -> ErrorT e m a

restoreM :: StM (ErrorT e m) a -> ErrorT e m a

MonadBaseControl b (CompositionBaseT ts m) => MonadBaseControl b (CompositionC ts m)

Defined in Control.Effect.Carrier.Internal.Compose

Associated Types

type StM (CompositionC ts m) a

Methods

liftBaseWith :: (RunInBase (CompositionC ts m) b -> b a) -> CompositionC ts m a

restoreM :: StM (CompositionC ts m) a -> CompositionC ts m a

MonadBaseControl b m => MonadBaseControl b (Effly m)

Defined in Control.Effect.Internal.Effly

Associated Types

type StM (Effly m) a

Methods

liftBaseWith :: (RunInBase (Effly m) b -> b a) -> Effly m a

restoreM :: StM (Effly m) a -> Effly m a

MonadBaseControl b m => MonadBaseControl b (InterpretPrimSimpleC e m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (InterpretPrimSimpleC e m) a

Methods

liftBaseWith :: (RunInBase (InterpretPrimSimpleC e m) b -> b a) -> InterpretPrimSimpleC e m a

restoreM :: StM (InterpretPrimSimpleC e m) a -> InterpretPrimSimpleC e m a

MonadBaseControl b m => MonadBaseControl b (InterpretSimpleC e m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (InterpretSimpleC e m) a

Methods

liftBaseWith :: (RunInBase (InterpretSimpleC e m) b -> b a) -> InterpretSimpleC e m a

restoreM :: StM (InterpretSimpleC e m) a -> InterpretSimpleC e m a

MonadBaseControl b m => MonadBaseControl b (EmbedC m)

Defined in Control.Effect.Embed

Associated Types

type StM (EmbedC m) a

Methods

liftBaseWith :: (RunInBase (EmbedC m) b -> b a) -> EmbedC m a

restoreM :: StM (EmbedC m) a -> EmbedC m a

MonadBaseControl b m => MonadBaseControl b (RunMC m)

Defined in Control.Effect.Embed

Associated Types

type StM (RunMC m) a

Methods

liftBaseWith :: (RunInBase (RunMC m) b -> b a) -> RunMC m a

restoreM :: StM (RunMC m) a -> RunMC m a

(Monoid s, MonadBaseControl b m) => MonadBaseControl b (WriterCPS s m)

Defined in Control.Effect.Type.Internal.BaseControl

Associated Types

type StM (WriterCPS s m) a

Methods

liftBaseWith :: (RunInBase (WriterCPS s m) b -> b a) -> WriterCPS s m a

restoreM :: StM (WriterCPS s m) a -> WriterCPS s m a

(Monoid o, MonadBaseControl b m) => MonadBaseControl b (WriterLazyC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (WriterLazyC o m) a

Methods

liftBaseWith :: (RunInBase (WriterLazyC o m) b -> b a) -> WriterLazyC o m a

restoreM :: StM (WriterLazyC o m) a -> WriterLazyC o m a

(Monoid o, MonadBaseControl b m) => MonadBaseControl b (ListenLazyC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (ListenLazyC o m) a

Methods

liftBaseWith :: (RunInBase (ListenLazyC o m) b -> b a) -> ListenLazyC o m a

restoreM :: StM (ListenLazyC o m) a -> ListenLazyC o m a

(Monoid o, MonadBaseControl b m) => MonadBaseControl b (TellLazyC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (TellLazyC o m) a

Methods

liftBaseWith :: (RunInBase (TellLazyC o m) b -> b a) -> TellLazyC o m a

restoreM :: StM (TellLazyC o m) a -> TellLazyC o m a

(MonadBaseControl b m, Monoid o) => MonadBaseControl b (WriterC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (WriterC o m) a

Methods

liftBaseWith :: (RunInBase (WriterC o m) b -> b a) -> WriterC o m a

restoreM :: StM (WriterC o m) a -> WriterC o m a

(MonadBaseControl b m, Monoid o) => MonadBaseControl b (ListenC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (ListenC o m) a

Methods

liftBaseWith :: (RunInBase (ListenC o m) b -> b a) -> ListenC o m a

restoreM :: StM (ListenC o m) a -> ListenC o m a

(MonadBaseControl b m, Monoid o) => MonadBaseControl b (TellC o m)

Defined in Control.Effect.Internal.Writer

Associated Types

type StM (TellC o m) a

Methods

liftBaseWith :: (RunInBase (TellC o m) b -> b a) -> TellC o m a

restoreM :: StM (TellC o m) a -> TellC o m a

MonadBaseControl b m => MonadBaseControl b (StateLazyC s m)

Defined in Control.Effect.Internal.State

Associated Types

type StM (StateLazyC s m) a

Methods

liftBaseWith :: (RunInBase (StateLazyC s m) b -> b a) -> StateLazyC s m a

restoreM :: StM (StateLazyC s m) a -> StateLazyC s m a

MonadBaseControl b m => MonadBaseControl b (StateC s m)

Defined in Control.Effect.Internal.State

Associated Types

type StM (StateC s m) a

Methods

liftBaseWith :: (RunInBase (StateC s m) b -> b a) -> StateC s m a

restoreM :: StM (StateC s m) a -> StateC s m a

MonadBaseControl b m => MonadBaseControl b (ReaderC i m)

Defined in Control.Effect.Internal.Reader

Associated Types

type StM (ReaderC i m) a

Methods

liftBaseWith :: (RunInBase (ReaderC i m) b -> b a) -> ReaderC i m a

restoreM :: StM (ReaderC i m) a -> ReaderC i m a

MonadBaseControl b m => MonadBaseControl b (UnwrapTopC e m)

Defined in Control.Effect.Internal.Newtype

Associated Types

type StM (UnwrapTopC e m) a

Methods

liftBaseWith :: (RunInBase (UnwrapTopC e m) b -> b a) -> UnwrapTopC e m a

restoreM :: StM (UnwrapTopC e m) a -> UnwrapTopC e m a

MonadBaseControl b m => MonadBaseControl b (UnwrapC e m)

Defined in Control.Effect.Internal.Newtype

Associated Types

type StM (UnwrapC e m) a

Methods

liftBaseWith :: (RunInBase (UnwrapC e m) b -> b a) -> UnwrapC e m a

restoreM :: StM (UnwrapC e m) a -> UnwrapC e m a

MonadBaseControl b m => MonadBaseControl b (ErrorToIOSimpleC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ErrorToIOSimpleC e m) a

Methods

liftBaseWith :: (RunInBase (ErrorToIOSimpleC e m) b -> b a) -> ErrorToIOSimpleC e m a

restoreM :: StM (ErrorToIOSimpleC e m) a -> ErrorToIOSimpleC e m a

MonadBaseControl b m => MonadBaseControl b (InterpretErrorSimpleC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (InterpretErrorSimpleC e m) a

Methods

liftBaseWith :: (RunInBase (InterpretErrorSimpleC e m) b -> b a) -> InterpretErrorSimpleC e m a

restoreM :: StM (InterpretErrorSimpleC e m) a -> InterpretErrorSimpleC e m a

MonadBaseControl b m => MonadBaseControl b (ErrorToIOAsExcC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ErrorToIOAsExcC e m) a

Methods

liftBaseWith :: (RunInBase (ErrorToIOAsExcC e m) b -> b a) -> ErrorToIOAsExcC e m a

restoreM :: StM (ErrorToIOAsExcC e m) a -> ErrorToIOAsExcC e m a

MonadBaseControl b m => MonadBaseControl b (ErrorToErrorIOAsExcC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ErrorToErrorIOAsExcC e m) a

Methods

liftBaseWith :: (RunInBase (ErrorToErrorIOAsExcC e m) b -> b a) -> ErrorToErrorIOAsExcC e m a

restoreM :: StM (ErrorToErrorIOAsExcC e m) a -> ErrorToErrorIOAsExcC e m a

MonadBaseControl b m => MonadBaseControl b (ErrorC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ErrorC e m) a

Methods

liftBaseWith :: (RunInBase (ErrorC e m) b -> b a) -> ErrorC e m a

restoreM :: StM (ErrorC e m) a -> ErrorC e m a

MonadBaseControl b m => MonadBaseControl b (ThrowC e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ThrowC e m) a

Methods

liftBaseWith :: (RunInBase (ThrowC e m) b -> b a) -> ThrowC e m a

restoreM :: StM (ThrowC e m) a -> ThrowC e m a

MonadBaseControl b m => MonadBaseControl b (SafeErrorToErrorIOSimpleC exc m)

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

MonadBaseControl b m => MonadBaseControl b (SafeErrorToIOSimpleC exc m)

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

MonadBaseControl b m => MonadBaseControl b (SafeErrorC exc m)

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

MonadBaseControl b m => MonadBaseControl b (FreshEnumC uniq m)

Defined in Control.Effect.Fresh

Associated Types

type StM (FreshEnumC uniq m) a

Methods

liftBaseWith :: (RunInBase (FreshEnumC uniq m) b -> b a) -> FreshEnumC uniq m a

restoreM :: StM (FreshEnumC uniq m) a -> FreshEnumC uniq m a

MonadBaseControl b m => MonadBaseControl b (WriterTVarC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (WriterTVarC o m) a

Methods

liftBaseWith :: (RunInBase (WriterTVarC o m) b -> b a) -> WriterTVarC o m a

restoreM :: StM (WriterTVarC o m) a -> WriterTVarC o m a

MonadBaseControl b m => MonadBaseControl b (ListenTVarC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (ListenTVarC o m) a

Methods

liftBaseWith :: (RunInBase (ListenTVarC o m) b -> b a) -> ListenTVarC o m a

restoreM :: StM (ListenTVarC o m) a -> ListenTVarC o m a

MonadBaseControl b m => MonadBaseControl b (WriterToBracketC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (WriterToBracketC o m) a

Methods

liftBaseWith :: (RunInBase (WriterToBracketC o m) b -> b a) -> WriterToBracketC o m a

restoreM :: StM (WriterToBracketC o m) a -> WriterToBracketC o m a

MonadBaseControl b m => MonadBaseControl b (WriterIntoEndoWriterC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (WriterIntoEndoWriterC o m) a

Methods

liftBaseWith :: (RunInBase (WriterIntoEndoWriterC o m) b -> b a) -> WriterIntoEndoWriterC o m a

restoreM :: StM (WriterIntoEndoWriterC o m) a -> WriterIntoEndoWriterC o m a

MonadBaseControl b m => MonadBaseControl b (ListenIntoEndoListenC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (ListenIntoEndoListenC o m) a

Methods

liftBaseWith :: (RunInBase (ListenIntoEndoListenC o m) b -> b a) -> ListenIntoEndoListenC o m a

restoreM :: StM (ListenIntoEndoListenC o m) a -> ListenIntoEndoListenC o m a

MonadBaseControl b m => MonadBaseControl b (TellListLazyC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (TellListLazyC o m) a

Methods

liftBaseWith :: (RunInBase (TellListLazyC o m) b -> b a) -> TellListLazyC o m a

restoreM :: StM (TellListLazyC o m) a -> TellListLazyC o m a

MonadBaseControl b m => MonadBaseControl b (TellListC o m)

Defined in Control.Effect.Writer

Associated Types

type StM (TellListC o m) a

Methods

liftBaseWith :: (RunInBase (TellListC o m) b -> b a) -> TellListC o m a

restoreM :: StM (TellListC o m) a -> TellListC o m a

MonadBaseControl b m => MonadBaseControl b (InterceptRC e m)

Defined in Control.Effect.Internal.Intercept

Associated Types

type StM (InterceptRC e m) a

Methods

liftBaseWith :: (RunInBase (InterceptRC e m) b -> b a) -> InterceptRC e m a

restoreM :: StM (InterceptRC e m) a -> InterceptRC e m a

MonadBaseControl b m => MonadBaseControl b (InterpretFailC h m)

Defined in Control.Effect.Fail

Associated Types

type StM (InterpretFailC h m) a

Methods

liftBaseWith :: (RunInBase (InterpretFailC h m) b -> b a) -> InterpretFailC h m a

restoreM :: StM (InterpretFailC h m) a -> InterpretFailC h m a

MonadBaseControl b m => MonadBaseControl b (InterpretAltC h m)

Defined in Control.Effect.Alt

Associated Types

type StM (InterpretAltC h m) a

Methods

liftBaseWith :: (RunInBase (InterpretAltC h m) b -> b a) -> InterpretAltC h m a

restoreM :: StM (InterpretAltC h m) a -> InterpretAltC h m a

MonadBaseControl b m => MonadBaseControl b (SubsumeC e m)

Defined in Control.Effect.Internal

Associated Types

type StM (SubsumeC e m) a

Methods

liftBaseWith :: (RunInBase (SubsumeC e m) b -> b a) -> SubsumeC e m a

restoreM :: StM (SubsumeC e m) a -> SubsumeC e m a

MonadBaseControl b m => MonadBaseControl b (IntroC top new m)

Defined in Control.Effect.Carrier.Internal.Intro

Associated Types

type StM (IntroC top new m) a

Methods

liftBaseWith :: (RunInBase (IntroC top new m) b -> b a) -> IntroC top new m a

restoreM :: StM (IntroC top new m) a -> IntroC top new m a

MonadBaseControl b m => MonadBaseControl b (ReinterpretSimpleC e new m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (ReinterpretSimpleC e new m) a

Methods

liftBaseWith :: (RunInBase (ReinterpretSimpleC e new m) b -> b a) -> ReinterpretSimpleC e new m a

restoreM :: StM (ReinterpretSimpleC e new m) a -> ReinterpretSimpleC e new m a

MonadBaseControl b m => MonadBaseControl b (InterpretC h e m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (InterpretC h e m) a

Methods

liftBaseWith :: (RunInBase (InterpretC h e m) b -> b a) -> InterpretC h e m a

restoreM :: StM (InterpretC h e m) a -> InterpretC h e m a

MonadBaseControl b m => MonadBaseControl b (InterpretPrimC s e m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (InterpretPrimC s e m) a

Methods

liftBaseWith :: (RunInBase (InterpretPrimC s e m) b -> b a) -> InterpretPrimC s e m a

restoreM :: StM (InterpretPrimC s e m) a -> InterpretPrimC s e m a

MonadBaseControl b m => MonadBaseControl b (UnionC l m)

Defined in Control.Effect.Union

Associated Types

type StM (UnionC l m) a

Methods

liftBaseWith :: (RunInBase (UnionC l m) b -> b a) -> UnionC l m a

restoreM :: StM (UnionC l m) a -> UnionC l m a

MonadBaseControl b m => MonadBaseControl b (WrapC e e' m)

Defined in Control.Effect.Internal.Newtype

Associated Types

type StM (WrapC e e' m) a

Methods

liftBaseWith :: (RunInBase (WrapC e e' m) b -> b a) -> WrapC e e' m a

restoreM :: StM (WrapC e e' m) a -> WrapC e e' m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (RWST r w s m) a

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a

restoreM :: StM (RWST r w s m) a -> RWST r w s m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (RWST r w s m) a

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a

restoreM :: StM (RWST r w s m) a -> RWST r w s m a

MonadBaseControl b (t (u m)) => MonadBaseControl b (ComposeT t u m)

Defined in Control.Effect.Carrier.Internal.Compose

Associated Types

type StM (ComposeT t u m) a

Methods

liftBaseWith :: (RunInBase (ComposeT t u m) b -> b a) -> ComposeT t u m a

restoreM :: StM (ComposeT t u m) a -> ComposeT t u m a

MonadBaseControl b m => MonadBaseControl b (ReinterpretC h e new m)

Defined in Control.Effect.Carrier.Internal.Interpret

Associated Types

type StM (ReinterpretC h e new m) a

Methods

liftBaseWith :: (RunInBase (ReinterpretC h e new m) b -> b a) -> ReinterpretC h e new m a

restoreM :: StM (ReinterpretC h e new m) a -> ReinterpretC h e new m a

MonadBaseControl b' m => MonadBaseControl b' (UnionizeC b m)

Defined in Control.Effect.Union

Associated Types

type StM (UnionizeC b m) a

Methods

liftBaseWith :: (RunInBase (UnionizeC b m) b' -> b' a) -> UnionizeC b m a

restoreM :: StM (UnionizeC b m) a -> UnionizeC b m a

MonadBaseControl b' m => MonadBaseControl b' (UnionizeHeadC b m)

Defined in Control.Effect.Union

Associated Types

type StM (UnionizeHeadC b m) a

Methods

liftBaseWith :: (RunInBase (UnionizeHeadC b m) b' -> b' a) -> UnionizeHeadC b m a

restoreM :: StM (UnionizeHeadC b m) a -> UnionizeHeadC b m a

MonadBaseControl b m => MonadBaseControl b (ErrorToIOC' s s' e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (ErrorToIOC' s s' e m) a

Methods

liftBaseWith :: (RunInBase (ErrorToIOC' s s' e m) b -> b a) -> ErrorToIOC' s s' e m a

restoreM :: StM (ErrorToIOC' s s' e m) a -> ErrorToIOC' s s' e m a

MonadBaseControl b m => MonadBaseControl b (InterpretErrorC' s s' e m)

Defined in Control.Effect.Internal.Error

Associated Types

type StM (InterpretErrorC' s s' e m) a

Methods

liftBaseWith :: (RunInBase (InterpretErrorC' s s' e m) b -> b a) -> InterpretErrorC' s s' e m a

restoreM :: StM (InterpretErrorC' s s' e m) a -> InterpretErrorC' s s' e m a

MonadBaseControl b m => MonadBaseControl b (SafeErrorToErrorIOC' s s' exc m)

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

MonadBaseControl b m => MonadBaseControl b (SafeErrorToIOC' s s' exc m)

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

MonadBaseControl b m => MonadBaseControl b (ExceptionallyC eff exc m)

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

(Monad m, MonadBaseControl b z, Coercible z m) => MonadBaseControl b (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Associated Types

type StM (GainBaseControlC b z m) a

Methods

liftBaseWith :: (RunInBase (GainBaseControlC b z m) b -> b a) -> GainBaseControlC b z m a

restoreM :: StM (GainBaseControlC b z m) a -> GainBaseControlC b z m a

MonadBaseControl (Either e) (Either e)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (Either e) a

Methods

liftBaseWith :: (RunInBase (Either e) (Either e) -> Either e a) -> Either e a

restoreM :: StM (Either e) a -> Either e a

MonadBaseControl (ST s) (ST s)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ST s) a

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a

restoreM :: StM (ST s) a -> ST s a

MonadBaseControl (ST s) (ST s)

Defined in Control.Monad.Trans.Control

Associated Types

type StM (ST s) a

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a

restoreM :: StM (ST s) a -> ST s a

MonadBaseControl ((->) r :: Type -> Type) ((->) r :: Type -> Type)

Defined in Control.Monad.Trans.Control

Associated Types

type StM ((->) r) a

Methods

liftBaseWith :: (RunInBase ((->) r) ((->) r) -> r -> a) -> r -> a

restoreM :: StM ((->) r) a -> r -> a

control :: MonadBaseControl b m => (RunInBase m b -> b (StM m a)) -> m a

An often used composition: control f = liftBaseWith f >>= restoreM

Example:

liftedBracket :: MonadBaseControl IO m => m a -> (a -> m b) -> (a -> m c) -> m c
liftedBracket acquire release action = control $ \runInBase ->
    bracket (runInBase acquire)
            (\saved -> runInBase (restoreM saved >>= release))
            (\saved -> runInBase (restoreM saved >>= action))

Threading utilities

threadBaseControlViaClass :: forall b t m a. (MonadTrans t, Monad m, forall z. MonadBaseControl b z => MonadBaseControl b (t z), forall z. Coercible z m => Coercible (t z) (t m)) => (forall x. BaseControl b m x -> m x) -> BaseControl b (t m) a -> t m a

A valid definition of threadEff for a ThreadsEff t (BaseControl b) instance, given that t lifts MonadBaseControl b for any b.

threadBaseControlViaUnlift :: forall b t m a. (Monad m, MonadTrans t, forall z. Monad z => Monad (t z), forall z. Coercible z m => Coercible (t z) (t m), forall z. Monad z => ThreadsEff t (Unlift z)) => (forall x. BaseControl b m x -> m x) -> BaseControl b (t m) a -> t m a

A valid definition of threadEff for a ThreadsEff (BaseControl b) t instance, given that t threads Unlift z for any Monad z.

Combinators for Algebras

powerAlgBaseControl :: forall m p a. Monad m => Algebra' p m a -> Algebra' (BaseControl m ': p) m a

Strengthen an Algebra p m by adding a BaseControl m handler

powerAlgBaseControlFinal :: forall b m p a. MonadBaseControl b m => Algebra' p m a -> Algebra' (BaseControl b ': p) m a

Strengthen an Algebra p m by adding a BaseControl b handler, where b is the final base monad.

Carriers

newtype GainBaseControlC b z m a

Constructors

GainBaseControlC

Fields

• unGainBaseControlC :: m a

Instances

(Monad m, MonadBase b z, Coercible z m) => MonadBase b (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

liftBase :: b α -> GainBaseControlC b z m α

(Monad m, MonadBaseControl b z, Coercible z m) => MonadBaseControl b (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Associated Types

type StM (GainBaseControlC b z m) a

Methods

liftBaseWith :: (RunInBase (GainBaseControlC b z m) b -> b a) -> GainBaseControlC b z m a

restoreM :: StM (GainBaseControlC b z m) a -> GainBaseControlC b z m a

MonadTrans (GainBaseControlC b z :: (Type -> Type) -> Type -> Type)

Defined in Control.Effect.BaseControl

Methods

lift :: Monad m => m a -> GainBaseControlC b z m a

MonadTransControl (GainBaseControlC b z :: (Type -> Type) -> Type -> Type)

Defined in Control.Effect.BaseControl

Associated Types

type StT (GainBaseControlC b z) a

Methods

liftWith :: Monad m => (Run (GainBaseControlC b z) -> m a) -> GainBaseControlC b z m a

restoreT :: Monad m => m (StT (GainBaseControlC b z) a) -> GainBaseControlC b z m a

Monad m => Monad (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

(>>=) :: GainBaseControlC b z m a -> (a -> GainBaseControlC b z m b0) -> GainBaseControlC b z m b0

(>>) :: GainBaseControlC b z m a -> GainBaseControlC b z m b0 -> GainBaseControlC b z m b0

return :: a -> GainBaseControlC b z m a

Functor m => Functor (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

fmap :: (a -> b0) -> GainBaseControlC b z m a -> GainBaseControlC b z m b0

(<$) :: a -> GainBaseControlC b z m b0 -> GainBaseControlC b z m a

MonadFix m => MonadFix (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

mfix :: (a -> GainBaseControlC b z m a) -> GainBaseControlC b z m a

MonadFail m => MonadFail (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

fail :: String -> GainBaseControlC b z m a

Applicative m => Applicative (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

pure :: a -> GainBaseControlC b z m a

(<*>) :: GainBaseControlC b z m (a -> b0) -> GainBaseControlC b z m a -> GainBaseControlC b z m b0

liftA2 :: (a -> b0 -> c) -> GainBaseControlC b z m a -> GainBaseControlC b z m b0 -> GainBaseControlC b z m c

(*>) :: GainBaseControlC b z m a -> GainBaseControlC b z m b0 -> GainBaseControlC b z m b0

(<*) :: GainBaseControlC b z m a -> GainBaseControlC b z m b0 -> GainBaseControlC b z m a

MonadIO m => MonadIO (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

liftIO :: IO a -> GainBaseControlC b z m a

Alternative m => Alternative (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

empty :: GainBaseControlC b z m a

(<|>) :: GainBaseControlC b z m a -> GainBaseControlC b z m a -> GainBaseControlC b z m a

some :: GainBaseControlC b z m a -> GainBaseControlC b z m [a]

many :: GainBaseControlC b z m a -> GainBaseControlC b z m [a]

MonadPlus m => MonadPlus (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

mzero :: GainBaseControlC b z m a

mplus :: GainBaseControlC b z m a -> GainBaseControlC b z m a -> GainBaseControlC b z m a

MonadThrow m => MonadThrow (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Methods

throwM :: Exception e => e -> GainBaseControlC b z m a

MonadCatch m => MonadCatch (GainBaseControlC b z m)

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

MonadMask m => MonadMask (GainBaseControlC b z m)

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)

Carrier m => Carrier (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

Associated Types

type Derivs (GainBaseControlC b z m) :: [Effect]

type Prims (GainBaseControlC b z m) :: [Effect]

Methods

algPrims :: Algebra' (Prims (GainBaseControlC b z m)) (GainBaseControlC b z m) a

reformulate :: Monad z0 => Reformulation' (Derivs (GainBaseControlC b z m)) (Prims (GainBaseControlC b z m)) (GainBaseControlC b z m) z0 a

algDerivs :: Algebra' (Derivs (GainBaseControlC b z m)) (GainBaseControlC b z m) a

type StT (GainBaseControlC b z :: (Type -> Type) -> Type -> Type) a

Defined in Control.Effect.BaseControl

type StT (GainBaseControlC b z :: (Type -> Type) -> Type -> Type) a = StT (IdentityT :: (Type -> Type) -> Type -> Type) a

type Derivs (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

type Derivs (GainBaseControlC b z m) = Derivs m

type Prims (GainBaseControlC b z m)

Defined in Control.Effect.BaseControl

type Prims (GainBaseControlC b z m) = Prims m

type StM (GainBaseControlC b z m) a

Defined in Control.Effect.BaseControl

type StM (GainBaseControlC b z m) a = StM z a

data BaseControlC m a

Instances

MonadTrans (BaseControlC :: (Type -> Type) -> Type -> Type)

Defined in Control.Effect.Internal.BaseControl

Methods

lift :: Monad m => m a -> BaseControlC m a

MonadTransControl (BaseControlC :: (Type -> Type) -> Type -> Type)

Defined in Control.Effect.Internal.BaseControl

Associated Types

type StT BaseControlC a

Methods

liftWith :: Monad m => (Run BaseControlC -> m a) -> BaseControlC m a

restoreT :: Monad m => m (StT BaseControlC a) -> BaseControlC m a

Monad m => Monad (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

(>>=) :: BaseControlC m a -> (a -> BaseControlC m b) -> BaseControlC m b

(>>) :: BaseControlC m a -> BaseControlC m b -> BaseControlC m b

return :: a -> BaseControlC m a

Functor m => Functor (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

fmap :: (a -> b) -> BaseControlC m a -> BaseControlC m b

(<$) :: a -> BaseControlC m b -> BaseControlC m a

MonadFix m => MonadFix (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

mfix :: (a -> BaseControlC m a) -> BaseControlC m a

MonadFail m => MonadFail (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

fail :: String -> BaseControlC m a

Applicative m => Applicative (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

pure :: a -> BaseControlC m a

(<*>) :: BaseControlC m (a -> b) -> BaseControlC m a -> BaseControlC m b

liftA2 :: (a -> b -> c) -> BaseControlC m a -> BaseControlC m b -> BaseControlC m c

(*>) :: BaseControlC m a -> BaseControlC m b -> BaseControlC m b

(<*) :: BaseControlC m a -> BaseControlC m b -> BaseControlC m a

MonadIO m => MonadIO (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

liftIO :: IO a -> BaseControlC m a

Alternative m => Alternative (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

empty :: BaseControlC m a

(<|>) :: BaseControlC m a -> BaseControlC m a -> BaseControlC m a

some :: BaseControlC m a -> BaseControlC m [a]

many :: BaseControlC m a -> BaseControlC m [a]

MonadPlus m => MonadPlus (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

mzero :: BaseControlC m a

mplus :: BaseControlC m a -> BaseControlC m a -> BaseControlC m a

MonadThrow m => MonadThrow (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

throwM :: Exception e => e -> BaseControlC m a

MonadCatch m => MonadCatch (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Methods

catch :: Exception e => BaseControlC m a -> (e -> BaseControlC m a) -> BaseControlC m a

MonadMask m => MonadMask (BaseControlC m)

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)

Carrier m => Carrier (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

Associated Types

type Derivs (BaseControlC m) :: [Effect]

type Prims (BaseControlC m) :: [Effect]

Methods

algPrims :: Algebra' (Prims (BaseControlC m)) (BaseControlC m) a

reformulate :: Monad z => Reformulation' (Derivs (BaseControlC m)) (Prims (BaseControlC m)) (BaseControlC m) z a

algDerivs :: Algebra' (Derivs (BaseControlC m)) (BaseControlC m) a

type StT (BaseControlC :: (Type -> Type) -> Type -> Type) a

Defined in Control.Effect.Internal.BaseControl

type StT (BaseControlC :: (Type -> Type) -> Type -> Type) a = StT (IdentityT :: (Type -> Type) -> Type -> Type) a

type Derivs (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

type Derivs (BaseControlC m) = Derivs (InterpretPrimC BaseControlH (BaseControl m) m)

type Prims (BaseControlC m)

Defined in Control.Effect.Internal.BaseControl

type Prims (BaseControlC m) = Prims (InterpretPrimC BaseControlH (BaseControl m) m)

type BaseControlToFinalC b = InterpretPrimC BaseControlToFinalH (BaseControl b)