Safe Haskell	Safe-Inferred
Language	Haskell2010

Effectful.Exception

Contents

Throwing
Catching (with recovery)
Cleanup (no recovery)
Utils
- Evaluation
- Check exception type
Low-level API
Re-exports from Control.Exception

Description

Support for runtime exceptions.

This module supplies thin wrappers over functions from Control.Exception as well as several utility functions for convenience.

Note: the Eff monad provides instances for MonadThrow, MonadCatch and MonadMask, so any existing code that uses them remains compatible.

Synopsis

throwIO :: (HasCallStack, Exception e) => e -> Eff es a
catch :: Exception e => Eff es a -> (e -> Eff es a) -> Eff es a
catchDeep :: (Exception e, NFData a) => Eff es a -> (e -> Eff es a) -> Eff es a
catchJust :: Exception e => (e -> Maybe b) -> Eff es a -> (b -> Eff es a) -> Eff es a
catchIf :: Exception e => (e -> Bool) -> Eff es a -> (e -> Eff es a) -> Eff es a
catchIO :: Eff es a -> (IOException -> Eff es a) -> Eff es a
catchSync :: Eff es a -> (SomeException -> Eff es a) -> Eff es a
catchSyncDeep :: NFData a => Eff es a -> (SomeException -> Eff es a) -> Eff es a
handle :: Exception e => (e -> Eff es a) -> Eff es a -> Eff es a
handleDeep :: (Exception e, NFData a) => (e -> Eff es a) -> Eff es a -> Eff es a
handleJust :: (HasCallStack, Exception e) => (e -> Maybe b) -> (b -> Eff es a) -> Eff es a -> Eff es a
handleIf :: Exception e => (e -> Bool) -> (e -> Eff es a) -> Eff es a -> Eff es a
handleIO :: (IOException -> Eff es a) -> Eff es a -> Eff es a
handleSync :: (SomeException -> Eff es a) -> Eff es a -> Eff es a
handleSyncDeep :: NFData a => (SomeException -> Eff es a) -> Eff es a -> Eff es a
try :: Exception e => Eff es a -> Eff es (Either e a)
tryDeep :: (Exception e, NFData a) => Eff es a -> Eff es (Either e a)
tryJust :: Exception e => (e -> Maybe b) -> Eff es a -> Eff es (Either b a)
tryIf :: Exception e => (e -> Bool) -> Eff es a -> Eff es (Either e a)
tryIO :: Eff es a -> Eff es (Either IOException a)
trySync :: Eff es a -> Eff es (Either SomeException a)
trySyncDeep :: NFData a => Eff es a -> Eff es (Either SomeException a)
data Handler (m :: Type -> Type) a = Exception e => Handler (e -> m a)
catches :: Eff es a -> [Handler (Eff es) a] -> Eff es a
catchesDeep :: NFData a => Eff es a -> [Handler (Eff es) a] -> Eff es a
bracket :: Eff es a -> (a -> Eff es b) -> (a -> Eff es c) -> Eff es c
bracket_ :: Eff es a -> Eff es b -> Eff es c -> Eff es c
bracketOnError :: Eff es a -> (a -> Eff es b) -> (a -> Eff es c) -> Eff es c
generalBracket :: Eff es a -> (a -> ExitCase c -> Eff es b) -> (a -> Eff es c) -> Eff es (c, b)
data ExitCase a
- = ExitCaseSuccess a
- | ExitCaseException SomeException
- | ExitCaseAbort
finally :: Eff es a -> Eff es b -> Eff es a
onException :: Eff es a -> Eff es b -> Eff es a
evaluate :: a -> Eff es a
evaluateDeep :: NFData a => a -> Eff es a
isSyncException :: Exception e => e -> Bool
isAsyncException :: Exception e => e -> Bool
mask :: ((forall r. Eff es r -> Eff es r) -> Eff es a) -> Eff es a
mask_ :: Eff es a -> Eff es a
uninterruptibleMask :: ((forall r. Eff es r -> Eff es r) -> Eff es a) -> Eff es a
uninterruptibleMask_ :: Eff es a -> Eff es a
data MaskingState
- = Unmasked
- | MaskedInterruptible
- | MaskedUninterruptible
getMaskingState :: Eff es MaskingState
interruptible :: Eff es a -> Eff es a
allowInterrupt :: Eff es ()
data SomeException = Exception e => SomeException e
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
data IOException
data ArithException
- = Overflow
- | Underflow
- | LossOfPrecision
- | DivideByZero
- | Denormal
- | RatioZeroDenominator
data ArrayException
- = IndexOutOfBounds String
- | UndefinedElement String
newtype AssertionFailed = AssertionFailed String
newtype NoMethodError = NoMethodError String
newtype PatternMatchFail = PatternMatchFail String
newtype RecConError = RecConError String
newtype RecSelError = RecSelError String
newtype RecUpdError = RecUpdError String
data ErrorCall where
- ErrorCallWithLocation String String
- pattern ErrorCall :: String -> ErrorCall
newtype TypeError = TypeError String
data SomeAsyncException = Exception e => SomeAsyncException e
data AsyncException
- = StackOverflow
- | HeapOverflow
- | ThreadKilled
- | UserInterrupt
asyncExceptionToException :: Exception e => e -> SomeException
asyncExceptionFromException :: Exception e => SomeException -> Maybe e
data NonTermination = NonTermination
data NestedAtomically = NestedAtomically
data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
data AllocationLimitExceeded = AllocationLimitExceeded
newtype CompactionFailed = CompactionFailed String
data Deadlock = Deadlock
assert :: Bool -> a -> a

Throwing

throwIO Source #

Arguments

:: (HasCallStack, Exception e)
=> e	The error.
-> Eff es a

Lifted throwIO.

Catching (with recovery)

Note: do not use catch, handle or try to catch SomeException unless you're really sure you want to catch all exceptions (including asynchronous ones). Instead:

If you want to catch all exceptions, run a cleanup action and rethrow, use one of the functions from the cleanup section.
If you want to catch all synchronous exceptions, use catchSync, handleSync or trySync.

catch Source #

Arguments

:: Exception e
=> Eff es a
-> (e -> Eff es a)	The exception handler.
-> Eff es a

Lifted catch.

catchDeep Source #

Arguments

:: (Exception e, NFData a)
=> Eff es a
-> (e -> Eff es a)	The exception handler.
-> Eff es a

A variant of catch that fully forces evaluation of the result value to find all impure exceptions.

catchJust Source #

Arguments

:: Exception e
=> (e -> Maybe b)	The predicate.
-> Eff es a
-> (b -> Eff es a)	The exception handler.
-> Eff es a

Lifted catchJust.

catchIf Source #

Arguments

:: Exception e
=> (e -> Bool)	The predicate.
-> Eff es a
-> (e -> Eff es a)	The exception handler.
-> Eff es a

Catch an exception only if it satisfies a specific predicate.

catchIO Source #

Arguments

:: Eff es a
-> (IOException -> Eff es a)	The exception handler.
-> Eff es a

catch specialized to catch IOException.

catchSync Source #

Arguments

:: Eff es a
-> (SomeException -> Eff es a)	The exception handler.
-> Eff es a

catch specialized to catch all exceptions considered to be synchronous.

catchSync ≡ catchIf @SomeException isSyncException

See the check exception type section for more information.

catchSyncDeep Source #

Arguments

:: NFData a
=> Eff es a
-> (SomeException -> Eff es a)	The exception handler.
-> Eff es a

A variant of catchSync that fully forces evaluation of the result value to find all impure exceptions.

handle Source #

Arguments

:: Exception e
=> (e -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catch.

handleDeep Source #

Arguments

:: (Exception e, NFData a)
=> (e -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchDeep.

handleJust Source #

Arguments

:: (HasCallStack, Exception e)
=> (e -> Maybe b)	The predicate.
-> (b -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchJust.

handleIf Source #

Arguments

:: Exception e
=> (e -> Bool)	The predicate.
-> (e -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchIf.

handleIO Source #

Arguments

:: (IOException -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchIO.

handleSync Source #

Arguments

:: (SomeException -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchSync.

handleSyncDeep Source #

Arguments

:: NFData a
=> (SomeException -> Eff es a)	The exception handler.
-> Eff es a
-> Eff es a

Flipped version of catchSyncDeep.

try Source #

Arguments

:: Exception e
=> Eff es a	The action.
-> Eff es (Either e a)

Lifted try.

tryDeep Source #

Arguments

:: (Exception e, NFData a)
=> Eff es a	The action.
-> Eff es (Either e a)

A variant of try that fully forces evaluation of the result value to find all impure exceptions.

tryJust Source #

Arguments

:: Exception e
=> (e -> Maybe b)	The predicate.
-> Eff es a
-> Eff es (Either b a)

Lifted tryJust.

tryIf Source #

Arguments

:: Exception e
=> (e -> Bool)	The predicate.
-> Eff es a
-> Eff es (Either e a)

Catch an exception only if it satisfies a specific predicate.

tryIO Source #

Arguments

:: Eff es a	The action.
-> Eff es (Either IOException a)

try specialized to catch IOException.

trySync Source #

Arguments

:: Eff es a	The action.
-> Eff es (Either SomeException a)

try specialized to catch all exceptions considered to be synchronous.

trySync ≡ tryIf @SomeException isSyncException

See the check exception type section for more information.

trySyncDeep Source #

Arguments

:: NFData a
=> Eff es a	The action.
-> Eff es (Either SomeException a)

A variant of trySync that fully forces evaluation of the result value to find all impure exceptions.

data Handler (m :: Type -> Type) a #

Generalized version of Handler

Constructors

Exception e => Handler (e -> m a)

Instances

Instances details

Monad m => Functor (Handler m)
Instance details Defined in Control.Monad.Catch Methods fmap :: (a -> b) -> Handler m a -> Handler m b # (<$) :: a -> Handler m b -> Handler m a #

catches Source #

Arguments

:: Eff es a
-> [Handler (Eff es) a]	The exception handlers.
-> Eff es a

Lifted catches.

catchesDeep Source #

Arguments

:: NFData a
=> Eff es a
-> [Handler (Eff es) a]	The exception handlers.
-> Eff es a

A variant of catches that fully forces evaluation of the result value to find all impure exceptions.

Cleanup (no recovery)

bracket Source #

Arguments

:: Eff es a	Computation to run first.
-> (a -> Eff es b)	Computation to run last.
-> (a -> Eff es c)	Computation to run in-between.
-> Eff es c

Lifted bracket.

bracket_ Source #

Arguments

:: Eff es a	Computation to run first.
-> Eff es b	Computation to run last.
-> Eff es c	Computation to run in-between.
-> Eff es c

Lifted bracket_.

bracketOnError Source #

Arguments

:: Eff es a	Computation to run first.
-> (a -> Eff es b)	Computation to run last when an exception or `Error` was thrown.
-> (a -> Eff es c)	Computation to run in-between.
-> Eff es c

Lifted bracketOnError.

generalBracket Source #

Arguments

:: Eff es a	Computation to run first.
-> (a -> ExitCase c -> Eff es b)	Computation to run last.
-> (a -> Eff es c)	Computation to run in-between.
-> Eff es (c, b)

Generalization of bracket.

See generalBracket for more information.

data ExitCase a #

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

Constructors

ExitCaseSuccess a
ExitCaseException SomeException
ExitCaseAbort

Instances

Instances details

Show a => Show (ExitCase a)
Instance details Defined in Control.Monad.Catch Methods showsPrec :: Int -> ExitCase a -> ShowS # show :: ExitCase a -> String # showList :: [ExitCase a] -> ShowS #

finally Source #

Arguments

:: Eff es a
-> Eff es b	Computation to run last.
-> Eff es a

Lifted finally.

onException Source #

Arguments

:: Eff es a
-> Eff es b	Computation to run last when an exception or `Error` was thrown.
-> Eff es a

Lifted onException.

Utils

Evaluation

evaluate :: a -> Eff es a Source #

Lifted evaluate.

evaluateDeep :: NFData a => a -> Eff es a Source #

Deeply evaluate a value using evaluate and NFData.

Check exception type

Note: there's no way to determine whether an exception was thrown synchronously or asynchronously, so these functions rely on a heuristic. Namely, an exception type is determined by its Exception instance.

Exception types with the default Exception instance are considered synchronous:

>>> data SyncEx = SyncEx deriving (Show)
>>> instance Exception SyncEx

>>> isSyncException SyncEx
True

>>> isAsyncException SyncEx
False

Whereas for asynchronous exceptions you need to define their Exception instance as follows:

>>> data AsyncEx = AsyncEx deriving (Show)
>>> :{
  instance Exception AsyncEx where
    toException = asyncExceptionToException
    fromException = asyncExceptionFromException
:}

>>> isSyncException AsyncEx
False

>>> isAsyncException AsyncEx
True

isSyncException :: Exception e => e -> Bool Source #

Check if the given exception is considered synchronous.

isAsyncException :: Exception e => e -> Bool Source #

Check if the given exception is considered asynchronous.

Low-level API

mask :: ((forall r. Eff es r -> Eff es r) -> Eff es a) -> Eff es a Source #

Lifted mask.

mask_ :: Eff es a -> Eff es a Source #

Lifted mask_.

uninterruptibleMask :: ((forall r. Eff es r -> Eff es r) -> Eff es a) -> Eff es a Source #

Lifted uninterruptibleMask.

uninterruptibleMask_ :: Eff es a -> Eff es a Source #

Lifted uninterruptibleMask_.

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

Instances details

Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
NFData MaskingState	Since: deepseq-1.4.4.0
Instance details Defined in Control.DeepSeq Methods rnf :: MaskingState -> () #
Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #

getMaskingState :: Eff es MaskingState Source #

Lifted getMaskingState.

interruptible :: Eff es a -> Eff es a Source #

Lifted interruptible.

allowInterrupt :: Eff es () Source #

Lifted allowInterrupt.

Re-exports from Control.Exception

The `SomeException` type

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

Instances details

Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #

The `Exception` class

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

Instances details

Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Exception NoMatchingContinuationPrompt	Since: base-4.18
Instance details Defined in Control.Exception.Base Methods toException :: NoMatchingContinuationPrompt -> SomeException # fromException :: SomeException -> Maybe NoMatchingContinuationPrompt # displayException :: NoMatchingContinuationPrompt -> String #
Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Exception Void	Since: base-4.8.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #

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".

Concrete exception types

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

Instances details

Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Show IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Eq IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #

data ArithException #

Arithmetic exceptions.

Constructors

Overflow
Underflow
LossOfPrecision
DivideByZero
Denormal
RatioZeroDenominator	Since: base-4.6.0.0

Instances

Instances details

Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Ord ArithException	Since: base-3.0
Instance details 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 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

Instances details

Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Eq ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Ord ArrayException	Since: base-4.2.0.0
Instance details 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 #

newtype AssertionFailed #

assert was applied to False.

Constructors

AssertionFailed String

Instances

Instances details

Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> 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

Instances details

Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Show NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS #

newtype PatternMatchFail #

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

Constructors

PatternMatchFail String

Instances

Instances details

Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Show PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> 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

Instances details

Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Show RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> 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

Instances details

Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Show RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> 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

Instances details

Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Show RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS #

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

Instances details

Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Eq ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Ord ErrorCall	Since: base-4.7.0.0
Instance details 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 #

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

Instances details

Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Show TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> TypeError -> ShowS # show :: TypeError -> String # showList :: [TypeError] -> ShowS #

Asynchronous exceptions

data SomeAsyncException #

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Constructors

Exception e => SomeAsyncException e

Instances

Instances details

Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> 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

Instances details

Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Eq AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Ord AsyncException	Since: base-4.2.0.0
Instance details 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 #

asyncExceptionToException :: Exception e => e -> SomeException #

Since: base-4.7.0.0

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

Since: base-4.7.0.0

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

Instances details

Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Show NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS #

data NestedAtomically #

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

Constructors

NestedAtomically

Instances

Instances details

Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Show NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> 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

Instances details

Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> 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

Instances details

Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #

data AllocationLimitExceeded #

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

Since: base-4.8.0.0

Constructors

AllocationLimitExceeded

Instances

Instances details

Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> 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

Instances details

Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> 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

Instances details

Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #

Assertions

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.

Throwing

Catching (with recovery)

Instances

Cleanup (no recovery)

Instances

Utils

Evaluation

Check exception type

Low-level API

Instances

Re-exports from Control.Exception

The SomeException type

Instances

The Exception class

Instances

Concrete exception types

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Asynchronous exceptions

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Assertions

The `SomeException` type

The `Exception` class