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

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

Instances

Functor μ => Functor (Handler μ)

Defined in Control.Monad.Exception

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.

Minimal complete definition

Nothing

Methods

getMaskingState :: μ MaskingState

Get the current masking state.

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

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

Run the provided computation with the specified MaskingState.

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

Instances

MonadMask IO

Defined in Control.Monad.Exception

Methods

getMaskingState :: IO MaskingState

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

MonadMask μ => MonadMask (ListT μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: ListT μ MaskingState

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

MonadMask μ => MonadMask (MaybeT μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: MaybeT μ MaskingState

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

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

Defined in Control.Monad.Exception

Methods

getMaskingState :: ErrorT e μ MaskingState

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

MonadMask μ => MonadMask (ExceptT e μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: ExceptT e μ MaskingState

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

MonadMask μ => MonadMask (ReaderT r μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: ReaderT r μ MaskingState

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

MonadMask μ => MonadMask (StateT s μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: StateT s μ MaskingState

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

MonadMask μ => MonadMask (StateT s μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: StateT s μ MaskingState

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

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

Defined in Control.Monad.Exception

Methods

getMaskingState :: WriterT w μ MaskingState

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

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

Defined in Control.Monad.Exception

Methods

getMaskingState :: WriterT w μ MaskingState

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

MonadMask μ => MonadMask (AbortT e μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: AbortT e μ MaskingState

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

MonadMask μ => MonadMask (FinishT β μ)

Defined in Control.Monad.Exception

Methods

getMaskingState :: FinishT β μ MaskingState

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

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

Defined in Control.Monad.Exception

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

Defined in Control.Monad.Exception

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

assert :: Bool -> a -> a

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

newtype TypeError

An expression that didn't typecheck during compile time was called. This is only possible with -fdefer-type-errors. The String gives details about the failed type check.

Since: base-4.9.0.0

Constructors

TypeError String

Instances

Exception TypeError

Since: base-4.9.0.0

Defined in Control.Exception.Base

Methods

toException :: TypeError -> SomeException

fromException :: SomeException -> Maybe TypeError

displayException :: TypeError -> String

Show TypeError

Since: base-4.9.0.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> TypeError -> ShowS

show :: TypeError -> String

showList :: [TypeError] -> ShowS

newtype RecUpdError

A record update was performed on a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The String gives information about the source location of the record update.

Constructors

RecUpdError String

Instances

Exception RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecUpdError -> SomeException

fromException :: SomeException -> Maybe RecUpdError

displayException :: RecUpdError -> String

Show RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecUpdError -> ShowS

show :: RecUpdError -> String

showList :: [RecUpdError] -> ShowS

newtype RecSelError

A record selector was applied to a constructor without the appropriate field. This can only happen with a datatype with multiple constructors, where some fields are in one constructor but not another. The String gives information about the source location of the record selector.

Constructors

RecSelError String

Instances

Exception RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecSelError -> SomeException

fromException :: SomeException -> Maybe RecSelError

displayException :: RecSelError -> String

Show RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecSelError -> ShowS

show :: RecSelError -> String

showList :: [RecSelError] -> ShowS

newtype RecConError

An uninitialised record field was used. The String gives information about the source location where the record was constructed.

Constructors

RecConError String

Instances

Exception RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecConError -> SomeException

fromException :: SomeException -> Maybe RecConError

displayException :: RecConError -> String

Show RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> RecConError -> ShowS

show :: RecConError -> String

showList :: [RecConError] -> ShowS

newtype PatternMatchFail

A pattern match failed. The String gives information about the source location of the pattern.

Constructors

PatternMatchFail String

Instances

Exception PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: PatternMatchFail -> SomeException

fromException :: SomeException -> Maybe PatternMatchFail

displayException :: PatternMatchFail -> String

Show PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> PatternMatchFail -> ShowS

show :: PatternMatchFail -> String

showList :: [PatternMatchFail] -> ShowS

data NonTermination

Thrown when the runtime system detects that the computation is guaranteed not to terminate. Note that there is no guarantee that the runtime system will notice whether any given computation is guaranteed to terminate or not.

Constructors

NonTermination

Instances

Exception NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NonTermination -> SomeException

fromException :: SomeException -> Maybe NonTermination

displayException :: NonTermination -> String

Show NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NonTermination -> ShowS

show :: NonTermination -> String

showList :: [NonTermination] -> ShowS

newtype NoMethodError

A class method without a definition (neither a default definition, nor a definition in the appropriate instance) was called. The String gives information about which method it was.

Constructors

NoMethodError String

Instances

Exception NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NoMethodError -> SomeException

fromException :: SomeException -> Maybe NoMethodError

displayException :: NoMethodError -> String

Show NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NoMethodError -> ShowS

show :: NoMethodError -> String

showList :: [NoMethodError] -> ShowS

data NestedAtomically

Thrown when the program attempts to call atomically, from the stm package, inside another call to atomically.

Constructors

NestedAtomically

Instances

Exception NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NestedAtomically -> SomeException

fromException :: SomeException -> Maybe NestedAtomically

displayException :: NestedAtomically -> String

Show NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NestedAtomically -> ShowS

show :: NestedAtomically -> String

showList :: [NestedAtomically] -> ShowS

mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a

This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".

data SomeAsyncException

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Constructors

Exception e => SomeAsyncException e

Instances

Exception SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> String

Show SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> SomeAsyncException -> ShowS

show :: SomeAsyncException -> String

showList :: [SomeAsyncException] -> ShowS

data Deadlock

There are no runnable threads, so the program is deadlocked. The Deadlock exception is raised in the main thread only.

Constructors

Deadlock

Instances

Exception Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> String

Show Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> Deadlock -> ShowS

show :: Deadlock -> String

showList :: [Deadlock] -> ShowS

newtype CompactionFailed

Compaction found an object that cannot be compacted. Functions cannot be compacted, nor can mutable objects or pinned objects. See compact.

Since: base-4.10.0.0

Constructors

CompactionFailed String

Instances

Exception CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException

fromException :: SomeException -> Maybe CompactionFailed

displayException :: CompactionFailed -> String

Show CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> CompactionFailed -> ShowS

show :: CompactionFailed -> String

showList :: [CompactionFailed] -> ShowS

data BlockedIndefinitelyOnSTM

The thread is waiting to retry an STM transaction, but there are no other references to any TVars involved, so it can't ever continue.

Constructors

BlockedIndefinitelyOnSTM

Instances

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM

displayException :: BlockedIndefinitelyOnSTM -> String

Show BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS

show :: BlockedIndefinitelyOnSTM -> String

showList :: [BlockedIndefinitelyOnSTM] -> ShowS

data BlockedIndefinitelyOnMVar

The thread is blocked on an MVar, but there are no other references to the MVar so it can't ever continue.

Constructors

BlockedIndefinitelyOnMVar

Instances

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar

displayException :: BlockedIndefinitelyOnMVar -> String

Show BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS

show :: BlockedIndefinitelyOnMVar -> String

showList :: [BlockedIndefinitelyOnMVar] -> ShowS

data AsyncException

Asynchronous exceptions.

Constructors

StackOverflow

The current thread's stack exceeded its limit. Since an exception has been raised, the thread's stack will certainly be below its limit again, but the programmer should take remedial action immediately.

HeapOverflow

The program's heap is reaching its limit, and the program should take action to reduce the amount of live data it has. Notes:

• It is undefined which thread receives this exception. GHC currently throws this to the same thread that receives UserInterrupt, but this may change in the future.
• The GHC RTS currently can only recover from heap overflow if it detects that an explicit memory limit (set via RTS flags). has been exceeded. Currently, failure to allocate memory from the operating system results in immediate termination of the program.

ThreadKilled

This exception is raised by another thread calling killThread, or by the system if it needs to terminate the thread for some reason.

UserInterrupt

This exception is raised by default in the main thread of the program when the user requests to terminate the program via the usual mechanism(s) (e.g. Control-C in the console).

Instances

Exception AsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException

fromException :: SomeException -> Maybe AsyncException

displayException :: AsyncException -> String

Show AsyncException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AsyncException -> ShowS

show :: AsyncException -> String

showList :: [AsyncException] -> ShowS

Eq AsyncException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

(==) :: AsyncException -> AsyncException -> Bool

(/=) :: AsyncException -> AsyncException -> Bool

Ord AsyncException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

compare :: AsyncException -> AsyncException -> Ordering

(<) :: AsyncException -> AsyncException -> Bool

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

(>) :: AsyncException -> AsyncException -> Bool

(>=) :: AsyncException -> AsyncException -> Bool

max :: AsyncException -> AsyncException -> AsyncException

min :: AsyncException -> AsyncException -> AsyncException

newtype AssertionFailed

assert was applied to False.

Constructors

AssertionFailed String

Instances

Exception AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException

fromException :: SomeException -> Maybe AssertionFailed

displayException :: AssertionFailed -> String

Show AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AssertionFailed -> ShowS

show :: AssertionFailed -> String

showList :: [AssertionFailed] -> ShowS

data ArrayException

Exceptions generated by array operations

Constructors

IndexOutOfBounds String

An attempt was made to index an array outside its declared bounds.

UndefinedElement String

An attempt was made to evaluate an element of an array that had not been initialized.

Instances

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

Show ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Eq ArrayException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

(==) :: ArrayException -> ArrayException -> Bool

(/=) :: ArrayException -> ArrayException -> Bool

Ord ArrayException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

Methods

compare :: ArrayException -> ArrayException -> Ordering

(<) :: ArrayException -> ArrayException -> Bool

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

(>) :: ArrayException -> ArrayException -> Bool

(>=) :: ArrayException -> ArrayException -> Bool

max :: ArrayException -> ArrayException -> ArrayException

min :: ArrayException -> ArrayException -> ArrayException

data AllocationLimitExceeded

This thread has exceeded its allocation limit. See setAllocationCounter and enableAllocationLimit.

Since: base-4.8.0.0

Constructors

AllocationLimitExceeded

Instances

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException

fromException :: SomeException -> Maybe AllocationLimitExceeded

displayException :: AllocationLimitExceeded -> String

Show AllocationLimitExceeded

Since: base-4.7.1.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AllocationLimitExceeded -> ShowS

show :: AllocationLimitExceeded -> String

showList :: [AllocationLimitExceeded] -> ShowS

asyncExceptionToException :: Exception e => e -> SomeException

Since: base-4.7.0.0

asyncExceptionFromException :: Exception e => SomeException -> Maybe e

Since: base-4.7.0.0

data MaskingState

Describes the behaviour of a thread when an asynchronous exception is received.

Constructors

Unmasked

asynchronous exceptions are unmasked (the normal state)

MaskedInterruptible

the state during mask: asynchronous exceptions are masked, but blocking operations may still be interrupted

MaskedUninterruptible

the state during uninterruptibleMask: asynchronous exceptions are masked, and blocking operations may not be interrupted

Instances

Show MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

Eq MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

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

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

data IOException

Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Instances

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

Show IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Eq IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

(==) :: IOException -> IOException -> Bool

(/=) :: IOException -> IOException -> Bool

Error IOException

Defined in Control.Monad.Trans.Error

Methods

noMsg :: IOException

strMsg :: String -> IOException

data ErrorCall

This is thrown when the user calls error. The first String is the argument given to error, second String is the location.

Constructors

ErrorCallWithLocation String String

Bundled Patterns

pattern ErrorCall :: String -> ErrorCall

Instances

Exception ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

toException :: ErrorCall -> SomeException

fromException :: SomeException -> Maybe ErrorCall

displayException :: ErrorCall -> String

Show ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> ErrorCall -> ShowS

show :: ErrorCall -> String

showList :: [ErrorCall] -> ShowS

Eq ErrorCall

Since: base-4.7.0.0

Defined in GHC.Exception

Methods

(==) :: ErrorCall -> ErrorCall -> Bool

(/=) :: ErrorCall -> ErrorCall -> Bool

Ord ErrorCall

Since: base-4.7.0.0

Defined in GHC.Exception

Methods

compare :: ErrorCall -> ErrorCall -> Ordering

(<) :: ErrorCall -> ErrorCall -> Bool

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

(>) :: ErrorCall -> ErrorCall -> Bool

(>=) :: ErrorCall -> ErrorCall -> Bool

max :: ErrorCall -> ErrorCall -> ErrorCall

min :: ErrorCall -> ErrorCall -> ErrorCall

class (Typeable e, Show e) => Exception e where

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException

fromException :: SomeException -> Maybe e

displayException :: e -> String

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Exception NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NestedAtomically -> SomeException

fromException :: SomeException -> Maybe NestedAtomically

displayException :: NestedAtomically -> String

Exception NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NoMethodError -> SomeException

fromException :: SomeException -> Maybe NoMethodError

displayException :: NoMethodError -> String

Exception NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NonTermination -> SomeException

fromException :: SomeException -> Maybe NonTermination

displayException :: NonTermination -> String

Exception PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: PatternMatchFail -> SomeException

fromException :: SomeException -> Maybe PatternMatchFail

displayException :: PatternMatchFail -> String

Exception RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecConError -> SomeException

fromException :: SomeException -> Maybe RecConError

displayException :: RecConError -> String

Exception RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecSelError -> SomeException

fromException :: SomeException -> Maybe RecSelError

displayException :: RecSelError -> String

Exception RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecUpdError -> SomeException

fromException :: SomeException -> Maybe RecUpdError

displayException :: RecUpdError -> String

Exception TypeError

Since: base-4.9.0.0

Defined in Control.Exception.Base

Methods

toException :: TypeError -> SomeException

fromException :: SomeException -> Maybe TypeError

displayException :: TypeError -> String

Exception ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

toException :: ErrorCall -> SomeException

fromException :: SomeException -> Maybe ErrorCall

displayException :: ErrorCall -> String

Exception ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException

fromException :: SomeException -> Maybe ArithException

displayException :: ArithException -> String

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException

fromException :: SomeException -> Maybe AllocationLimitExceeded

displayException :: AllocationLimitExceeded -> String

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

Exception AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException

fromException :: SomeException -> Maybe AssertionFailed

displayException :: AssertionFailed -> String

Exception AsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException

fromException :: SomeException -> Maybe AsyncException

displayException :: AsyncException -> String

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar

displayException :: BlockedIndefinitelyOnMVar -> String

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM

displayException :: BlockedIndefinitelyOnSTM -> String

Exception CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException

fromException :: SomeException -> Maybe CompactionFailed

displayException :: CompactionFailed -> String

Exception Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> String

Exception ExitCode

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException

fromException :: SomeException -> Maybe ExitCode

displayException :: ExitCode -> String

Exception FixIOException

Since: base-4.11.0.0

Defined in GHC.IO.Exception

Methods

toException :: FixIOException -> SomeException

fromException :: SomeException -> Maybe FixIOException

displayException :: FixIOException -> String

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

Exception SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> String

data ArithException

Arithmetic exceptions.

Constructors

Overflow

Underflow

LossOfPrecision

DivideByZero

Denormal

RatioZeroDenominator

Since: base-4.6.0.0

Instances

Exception ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException

fromException :: SomeException -> Maybe ArithException

displayException :: ArithException -> String

Show ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> ArithException -> ShowS

show :: ArithException -> String

showList :: [ArithException] -> ShowS

Eq ArithException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

(==) :: ArithException -> ArithException -> Bool

(/=) :: ArithException -> ArithException -> Bool

Ord ArithException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

compare :: ArithException -> ArithException -> Ordering

(<) :: ArithException -> ArithException -> Bool

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

(>) :: ArithException -> ArithException -> Bool

(>=) :: ArithException -> ArithException -> Bool

max :: ArithException -> ArithException -> ArithException

min :: ArithException -> ArithException -> ArithException

data SomeException

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Constructors

Exception e => SomeException e

Instances

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Show SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

MonadAbort SomeException STM

Defined in Control.Monad.Abort.Class

Methods

abort :: SomeException -> STM α

MonadAbort SomeException IO

Defined in Control.Monad.Abort.Class

Methods

abort :: SomeException -> IO α

MonadRecover SomeException STM

Defined in Control.Monad.Abort.Class

Methods

recover :: STM α -> (SomeException -> STM α) -> STM α

evaluate :: STM α -> STM (Either SomeException α)

MonadRecover SomeException IO

Defined in Control.Monad.Abort.Class

Methods

recover :: IO α -> (SomeException -> IO α) -> IO α

evaluate :: IO α -> IO (Either SomeException α)