Control.Monad.Exception

Documentation

exception :: Exception e => e -> α

forceWHNF :: MonadBase IO μ => α -> μ α

throw :: (MonadAbort SomeException μ, Exception e) => e -> μ α

throwIO :: (MonadBase IO μ, Exception e) => e -> μ α

catch :: (MonadRecover SomeException μ, Exception e) => μ α -> (e -> μ α) -> μ α

catchJust :: (MonadRecover SomeException μ, Exception e) => (e -> Maybe β) -> μ α -> (β -> μ α) -> μ α

handle :: (MonadRecover SomeException μ, Exception e) => (e -> μ α) -> μ α -> μ α

handleJust :: (MonadRecover SomeException μ, Exception e) => (e -> Maybe β) -> (β -> μ α) -> μ α -> μ α

data Handler μ α

Constructors

Exception e => Handler (e -> μ α)

catches :: MonadRecover SomeException μ => μ α -> [Handler μ α] -> μ α

try :: (MonadRecover SomeException μ, Exception e) => μ α -> μ (Either e α)

tryJust :: (MonadRecover SomeException μ, Exception e) => (e -> Maybe β) -> μ α -> μ (Either β α)

onException :: (MonadRecover SomeException μ, Exception e) => μ α -> (e -> μ β) -> μ α

onExceptions :: MonadRecover SomeException μ => μ α -> [Handler μ β] -> μ α

class (Applicative μ, Monad μ) => MonadFinally μ where

Minimal complete definition

finally'

Methods

finally' :: μ α -> (Maybe α -> μ β) -> μ (α, β)

finally :: μ α -> μ β -> μ α

Instances

MonadFinally IO

Methods

finally' :: IO α -> (Maybe α -> IO β) -> IO (α, β)

finally :: IO α -> IO β -> IO α

MonadFinally Identity

Methods

finally' :: Identity α -> (Maybe α -> Identity β) -> Identity (α, β)

finally :: Identity α -> Identity β -> Identity α

MonadFinally μ => MonadFinally (ListT μ)

Methods

finally' :: ListT μ α -> (Maybe α -> ListT μ β) -> ListT μ (α, β)

finally :: ListT μ α -> ListT μ β -> ListT μ α

MonadFinally μ => MonadFinally (MaybeT μ)

Methods

finally' :: MaybeT μ α -> (Maybe α -> MaybeT μ β) -> MaybeT μ (α, β)

finally :: MaybeT μ α -> MaybeT μ β -> MaybeT μ α

MonadFinally μ => MonadFinally (ExceptT e μ)

Methods

finally' :: ExceptT e μ α -> (Maybe α -> ExceptT e μ β) -> ExceptT e μ (α, β)

finally :: ExceptT e μ α -> ExceptT e μ β -> ExceptT e μ α

(MonadFinally μ, Error e) => MonadFinally (ErrorT e μ)

Methods

finally' :: ErrorT e μ α -> (Maybe α -> ErrorT e μ β) -> ErrorT e μ (α, β)

finally :: ErrorT e μ α -> ErrorT e μ β -> ErrorT e μ α

MonadFinally μ => MonadFinally (StateT s μ)

Methods

finally' :: StateT s μ α -> (Maybe α -> StateT s μ β) -> StateT s μ (α, β)

finally :: StateT s μ α -> StateT s μ β -> StateT s μ α

MonadFinally μ => MonadFinally (StateT s μ)

Methods

finally' :: StateT s μ α -> (Maybe α -> StateT s μ β) -> StateT s μ (α, β)

finally :: StateT s μ α -> StateT s μ β -> StateT s μ α

(MonadFinally μ, Monoid w) => MonadFinally (WriterT w μ)

Methods

finally' :: WriterT w μ α -> (Maybe α -> WriterT w μ β) -> WriterT w μ (α, β)

finally :: WriterT w μ α -> WriterT w μ β -> WriterT w μ α

(MonadFinally μ, Monoid w) => MonadFinally (WriterT w μ)

Methods

finally' :: WriterT w μ α -> (Maybe α -> WriterT w μ β) -> WriterT w μ (α, β)

finally :: WriterT w μ α -> WriterT w μ β -> WriterT w μ α

MonadFinally μ => MonadFinally (AbortT e μ)

Methods

finally' :: AbortT e μ α -> (Maybe α -> AbortT e μ β) -> AbortT e μ (α, β)

finally :: AbortT e μ α -> AbortT e μ β -> AbortT e μ α

MonadFinally μ => MonadFinally (FinishT β μ)

Methods

finally' :: FinishT β μ α -> (Maybe α -> FinishT β μ β) -> FinishT β μ (α, β)

finally :: FinishT β μ α -> FinishT β μ β -> FinishT β μ α

MonadFinally μ => MonadFinally (ReaderT * r μ)

Methods

finally' :: ReaderT * r μ α -> (Maybe α -> ReaderT * r μ β) -> ReaderT * r μ (α, β)

finally :: ReaderT * r μ α -> ReaderT * r μ β -> ReaderT * r μ α

(MonadFinally μ, Monoid w) => MonadFinally (RWST r w s μ)

Methods

finally' :: RWST r w s μ α -> (Maybe α -> RWST r w s μ β) -> RWST r w s μ (α, β)

finally :: RWST r w s μ α -> RWST r w s μ β -> RWST r w s μ α

(MonadFinally μ, Monoid w) => MonadFinally (RWST r w s μ)

Methods

finally' :: RWST r w s μ α -> (Maybe α -> RWST r w s μ β) -> RWST r w s μ (α, β)

finally :: RWST r w s μ α -> RWST r w s μ β -> RWST r w s μ α

onEscape :: MonadFinally μ => μ α -> μ β -> μ α

tryAll :: MonadFinally μ => [μ α] -> μ ()

class (Applicative μ, Monad μ, Ord m, Bounded m) => MonadMask m μ | μ -> m where

Minimal complete definition

defMaskingState, getMaskingState, setMaskingState

Methods

defMaskingState :: Proxy μ -> m

getMaskingState :: μ m

setMaskingState :: m -> μ α -> μ α

Instances

MonadMask () Identity

Methods

defMaskingState :: Proxy (* -> *) Identity -> ()

getMaskingState :: Identity ()

setMaskingState :: () -> Identity α -> Identity α

MonadMask MaskingState IO

Methods

defMaskingState :: Proxy (* -> *) IO -> MaskingState

getMaskingState :: IO MaskingState

setMaskingState :: MaskingState -> IO α -> IO α

MonadMask m μ => MonadMask m (ListT μ)

Methods

defMaskingState :: Proxy (* -> *) (ListT μ) -> m

getMaskingState :: ListT μ m

setMaskingState :: m -> ListT μ α -> ListT μ α

MonadMask m μ => MonadMask m (MaybeT μ)

Methods

defMaskingState :: Proxy (* -> *) (MaybeT μ) -> m

getMaskingState :: MaybeT μ m

setMaskingState :: m -> MaybeT μ α -> MaybeT μ α

(MonadMask m μ, Monoid w) => MonadMask m (WriterT w μ)

Methods

defMaskingState :: Proxy (* -> *) (WriterT w μ) -> m

getMaskingState :: WriterT w μ m

setMaskingState :: m -> WriterT w μ α -> WriterT w μ α

(MonadMask m μ, Monoid w) => MonadMask m (WriterT w μ)

Methods

defMaskingState :: Proxy (* -> *) (WriterT w μ) -> m

getMaskingState :: WriterT w μ m

setMaskingState :: m -> WriterT w μ α -> WriterT w μ α

MonadMask m μ => MonadMask m (StateT s μ)

Methods

defMaskingState :: Proxy (* -> *) (StateT s μ) -> m

getMaskingState :: StateT s μ m

setMaskingState :: m -> StateT s μ α -> StateT s μ α

MonadMask m μ => MonadMask m (StateT s μ)

Methods

defMaskingState :: Proxy (* -> *) (StateT s μ) -> m

getMaskingState :: StateT s μ m

setMaskingState :: m -> StateT s μ α -> StateT s μ α

MonadMask m μ => MonadMask m (ExceptT e μ)

Methods

defMaskingState :: Proxy (* -> *) (ExceptT e μ) -> m

getMaskingState :: ExceptT e μ m

setMaskingState :: m -> ExceptT e μ α -> ExceptT e μ α

(MonadMask m μ, Error e) => MonadMask m (ErrorT e μ)

Methods

defMaskingState :: Proxy (* -> *) (ErrorT e μ) -> m

getMaskingState :: ErrorT e μ m

setMaskingState :: m -> ErrorT e μ α -> ErrorT e μ α

MonadMask m μ => MonadMask m (FinishT β μ)

Methods

defMaskingState :: Proxy (* -> *) (FinishT β μ) -> m

getMaskingState :: FinishT β μ m

setMaskingState :: m -> FinishT β μ α -> FinishT β μ α

MonadMask m μ => MonadMask m (AbortT e μ)

Methods

defMaskingState :: Proxy (* -> *) (AbortT e μ) -> m

getMaskingState :: AbortT e μ m

setMaskingState :: m -> AbortT e μ α -> AbortT e μ α

MonadMask m μ => MonadMask m (ReaderT * r μ)

Methods

defMaskingState :: Proxy (* -> *) (ReaderT * r μ) -> m

getMaskingState :: ReaderT * r μ m

setMaskingState :: m -> ReaderT * r μ α -> ReaderT * r μ α

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

Methods

defMaskingState :: Proxy (* -> *) (RWST r w s μ) -> m

getMaskingState :: RWST r w s μ m

setMaskingState :: m -> RWST r w s μ α -> RWST r w s μ α

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

Methods

defMaskingState :: Proxy (* -> *) (RWST r w s μ) -> m

getMaskingState :: RWST r w s μ m

setMaskingState :: m -> RWST r w s μ α -> RWST r w s μ α

mask :: forall m μ α. MonadMask m μ => ((forall η β. MonadMask m η => η β -> η β) -> μ α) -> μ α

mask_ :: forall m μ α. MonadMask m μ => μ α -> μ α

uninterruptibleMask :: MonadMask MaskingState μ => ((forall η β. MonadMask MaskingState η => η β -> η β) -> μ α) -> μ α

uninterruptibleMask_ :: MonadMask MaskingState μ => μ α -> μ α

bracket :: (MonadFinally μ, MonadMask m μ) => μ α -> (α -> μ β) -> (α -> μ γ) -> μ γ

bracket_ :: (MonadFinally μ, MonadMask m μ) => μ α -> μ β -> μ γ -> μ γ

bracketOnEscape :: (MonadFinally μ, MonadMask m μ) => μ α -> (α -> μ β) -> (α -> μ γ) -> μ γ

bracketOnError :: (MonadRecover e μ, MonadMask m μ) => μ α -> (α -> μ β) -> (α -> μ γ) -> μ γ

module Control.Monad.Abort.Class

module Control.Exception

Orphan instances

Bounded MaskingState

Methods

minBound :: MaskingState

maxBound :: MaskingState

Enum MaskingState

Methods

succ :: MaskingState -> MaskingState

pred :: MaskingState -> MaskingState

toEnum :: Int -> MaskingState

fromEnum :: MaskingState -> Int

enumFrom :: MaskingState -> [MaskingState]

enumFromThen :: MaskingState -> MaskingState -> [MaskingState]

enumFromTo :: MaskingState -> MaskingState -> [MaskingState]

enumFromThenTo :: MaskingState -> MaskingState -> MaskingState -> [MaskingState]

Ord MaskingState

Methods

compare :: MaskingState -> MaskingState -> Ordering

(<) :: MaskingState -> MaskingState -> Bool

(<=) :: MaskingState -> MaskingState -> Bool

(>) :: MaskingState -> MaskingState -> Bool

(>=) :: MaskingState -> MaskingState -> Bool

max :: MaskingState -> MaskingState -> MaskingState

min :: MaskingState -> MaskingState -> MaskingState