Control.Monad.Exception

A generalization of Control.Exception from the IO monad to MonadRecover SomeException.

Throwing exceptions

type MonadThrow μ = MonadAbort SomeException μ

An alias for MonadAbort SomeException μ.

exception :: Exception e => e -> α

Throw an exception from pure code.

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

Throw an exception from monadic code. An alias for abort . toException.

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

Thow an exception from the IO monad.

ioError :: MonadBase IO μ => IOError -> μ α

Raise an IOError in the IO monad.

throwTo :: (MonadBase IO μ, Exception e) => ThreadId -> e -> μ ()

Raise an exception in the target thread. See throwTo.

Catching exceptions

type MonadCatch μ = MonadRecover SomeException μ

An alias for MonadRecover SomeException μ.

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

Recover from the specified type of exceptions.

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

An alias for flip catch.

catchJust

Arguments

:: (MonadCatch μ, Exception e)

=> (e -> Maybe β)

Exception predicate

-> μ α

Main computation

-> (β -> μ α)

Exception handler

-> μ α

Recover from exceptions that satisfy the provided predicate.

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

An alias for flip . catchJust.

data Handler μ α

Exception handler.

Constructors

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

Instances

Functor μ => Functor (Handler * μ)

Methods

fmap :: (a -> b) -> Handler * μ a -> Handler * μ b

(<$) :: a -> Handler * μ b -> Handler * μ a

catches :: MonadCatch μ => μ α -> [Handler μ α] -> μ α

Recover from exceptions by sequentually trying to apply the provided handlers.

handles :: MonadCatch μ => [Handler μ α] -> μ α -> μ α

An alias for flip catches.

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

Recover from exceptions of the spesified type, wrapping them into Left.

tryJust

Arguments

:: (MonadCatch μ, Exception e)

=> (e -> Maybe β)

Exception predicate

-> μ α

Main compuration

-> μ (Either β α)

Recover from exceptions that satisfy the provided predicate, wrapping them into Left.

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

Evalute the argument to weak head normal form.

Asynchronous exception control

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

A class of monads that support masking of asynchronous exceptions.

Methods

getMaskingState :: μ MaskingState

Get the current masking state.

getMaskingState :: (MonadMask η, MonadTrans t, μ ~ t η) => μ MaskingState

Get the current masking state.

withMaskingState :: MaskingState -> μ α -> μ α

Run the provided computation with the specified MaskingState.

withMaskingState :: (MonadMask η, MonadTransControl t, μ ~ t η) => MaskingState -> μ α -> μ α

Run the provided computation with the specified MaskingState.

Instances

MonadMask IO

Methods

getMaskingState :: IO MaskingState

withMaskingState :: MaskingState -> IO α -> IO α

MonadMask μ => MonadMask (MaybeT μ)

Methods

getMaskingState :: MaybeT μ MaskingState

withMaskingState :: MaskingState -> MaybeT μ α -> MaybeT μ α

MonadMask μ => MonadMask (ListT μ)

Methods

getMaskingState :: ListT μ MaskingState

withMaskingState :: MaskingState -> ListT μ α -> ListT μ α

MonadMask μ => MonadMask (ExceptT e μ)

Methods

getMaskingState :: ExceptT e μ MaskingState

withMaskingState :: MaskingState -> ExceptT e μ α -> ExceptT e μ α

MonadMask μ => MonadMask (AbortT e μ)

Methods

getMaskingState :: AbortT e μ MaskingState

withMaskingState :: MaskingState -> AbortT e μ α -> AbortT e μ α

MonadMask μ => MonadMask (FinishT β μ)

Methods

getMaskingState :: FinishT β μ MaskingState

withMaskingState :: MaskingState -> FinishT β μ α -> FinishT β μ α

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

Methods

getMaskingState :: WriterT w μ MaskingState

withMaskingState :: MaskingState -> WriterT w μ α -> WriterT w μ α

MonadMask μ => MonadMask (StateT s μ)

Methods

getMaskingState :: StateT s μ MaskingState

withMaskingState :: MaskingState -> StateT s μ α -> StateT s μ α

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

Methods

getMaskingState :: ErrorT e μ MaskingState

withMaskingState :: MaskingState -> ErrorT e μ α -> ErrorT e μ α

MonadMask μ => MonadMask (StateT s μ)

Methods

getMaskingState :: StateT s μ MaskingState

withMaskingState :: MaskingState -> StateT s μ α -> StateT s μ α

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

Methods

getMaskingState :: WriterT w μ MaskingState

withMaskingState :: MaskingState -> WriterT w μ α -> WriterT w μ α

MonadMask μ => MonadMask (ReaderT * r μ)

Methods

getMaskingState :: ReaderT * r μ MaskingState

withMaskingState :: MaskingState -> ReaderT * r μ α -> ReaderT * r μ α

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

Methods

getMaskingState :: RWST r w s μ MaskingState

withMaskingState :: MaskingState -> RWST r w s μ α -> RWST r w s μ α

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

Methods

getMaskingState :: RWST r w s μ MaskingState

withMaskingState :: MaskingState -> RWST r w s μ α -> RWST r w s μ α

liftGetMaskingState :: (MonadMask μ, MonadTrans t) => t μ MaskingState

Lift getMaskingState through a monad transformer.

liftWithMaskingState :: (MonadTransControl t, MonadMask μ, Monad (t μ)) => MaskingState -> t μ α -> t μ α

Lift withMaskingState through a monad transformer.

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

Prevents asynchronous exceptions from being raised within the provided computation. Blocking operations can still be interrupted. Supplies the computation with withMaskingState s, where s is the current masking state.

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

An alias for mask . const.

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

Prevents asynchronous exceptions from being raised within the provided computation. Also prevents blocking operations from being interrupted. Supplies the computation with withMaskingState s, where s is the current masking state.

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

An alias for uninterruptibleMask . const.

interruptible :: MonadMask μ => μ α -> μ α

Allow asynchronous exceptions to be raised within the provided computation, even if the current masking state is MaskedInterruptible (but not in MaskedUninterruptible state).

allowInterrupt :: MonadMask μ => μ ()

An alias for interruptible (return ()).

Re-exports

module Control.Monad.Abort.Class

module Control.Monad.Finally

module Control.Exception