Control.Prim.Exception

Throwing

module Control.Prim.Monad.Throw

throw :: (Exception e, MonadPrim s m) => e -> m a

This is the same as throwIO, but works with any MonadPrim without restriction on RealWorld.

throwTo :: (MonadPrim s m, Exception e) => ThreadId -> e -> m ()

Similar to throwTo, except that it wraps any known non-async exception with SomeAsyncException. This is necessary, because receiving thread will get the exception in an asynchronous manner and without proper wrapping it will not be able to distinguish it from a regular synchronous exception

impureThrow :: Exception e => e -> a

Raise an impure exception from pure code. Returns a thunk, which will result in a supplied exceptionn being thrown when evaluated.

Since: 0.3.0

Catching

catch :: forall e a m. (Exception e, MonadUnliftPrim RW m) => m a -> (e -> m a) -> m a

Behaves exactly as catch, except that it works in any MonadUnliftPrim.

catchAny :: forall a m. MonadUnliftPrim RW m => m a -> (SomeException -> m a) -> m a

catchAnySync :: forall a m. MonadUnliftPrim RW m => m a -> (SomeException -> m a) -> m a

catchAll :: forall a m. MonadUnliftPrim RW m => m a -> (forall e. Exception e => e -> m a) -> m a

catchAllSync :: forall a m. MonadUnliftPrim RW m => m a -> (forall e. Exception e => e -> m a) -> m a

try :: (Exception e, MonadUnliftPrim RW m) => m a -> m (Either e a)

tryAny :: MonadUnliftPrim RW m => m a -> m (Either SomeException a)

tryAnySync :: MonadUnliftPrim RW m => m a -> m (Either SomeException a)

onException :: MonadUnliftPrim RW m => m a -> m b -> m a

Async safe version of onException.

Since: 0.1.0.0

withException :: (MonadUnliftPrim RW m, Exception e) => m a -> (e -> m b) -> m a

Run an action, while invoking an exception handler if that action fails for some reason. Exception handling function has async exceptions masked, but it is still interruptible, which can be undesired in some scenarios. If you are sure that the cleanup action does not deadlock and you do need hard guarantees that it gets executed you can run it as uninterruptible:

uninterruptibleMask $ \restore -> withException (restore action) handler

Since: 0.3.0

withAnyException :: MonadUnliftPrim RW m => m a -> (SomeException -> m b) -> m a

Same as withException, but will invoke exception handling function on all exceptions.

Since: 0.3.0

finally :: MonadUnliftPrim RW m => m a -> m b -> m a

bracket :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c

bracket_ :: MonadUnliftPrim RW m => m a -> m b -> m c -> m c

bracketOnError :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c

ufinally :: MonadUnliftPrim RW m => m a -> m b -> m a

ubracket :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c

ubracket_ :: MonadUnliftPrim RW m => m a -> m b -> m c -> m c

ubracketOnError :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c

mask :: forall a m s. MonadUnliftPrim s m => ((forall b. m b -> m b) -> m a) -> m a

Mask all asychronous exceptions, but keep it interruptible, unless the inherited state was uninterruptible already, in which case this action has no affect. Same as mask, except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within ST monad.

Since: 0.3.0

mask_ :: forall a m s. MonadUnliftPrim s m => m a -> m a

Mask all asychronous exceptions, but keep it interruptible, unless the inherited state was uninterruptible already, in which case this action has no affect. Same as mask_, except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within ST monad.

Since: 0.3.0

maskPrimBase_ :: forall a n m s. (MonadPrim s m, MonadPrimBase s n) => n a -> m a

uninterruptibleMask :: forall a m s. MonadUnliftPrim s m => ((forall b. m b -> m b) -> m a) -> m a

Mask all asychronous exceptions and mark it uninterruptible. Same as uninterruptibleMask, except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within ST monad.

Since: 0.3.0

uninterruptibleMask_ :: forall a m s. MonadUnliftPrim s m => m a -> m a

Mask all async exceptions and make sure evaluation cannot be interrupted. It is polymorphic in the state token because it is perfectly safe to use with ST actions that don't perform any allocations. It doesn't have to be restricted to RealWorld because it has no impact on other threads and can't affect the result of computation, moreover pure functions that implement tight loops are already non-interruptible. In fact using this function is more dangerous in IO than it is in ST, because misuse can lead to deadlocks in a concurrent setting.

Since: 0.3.0

uninterruptibleMaskPrimBase_ :: forall a n m s. (MonadPrimBase s n, MonadPrim s m) => n a -> m a

maskAsyncExceptions :: forall a m. MonadUnliftPrim RW m => m a -> m a

A direct wrapper around maskAsyncExceptions# primop. This is different and more dangerous than mask_ because it can turn uninterrubtable state into interruptable.

unmaskAsyncExceptions :: forall a m. MonadUnliftPrim RW m => m a -> m a

A direct wrapper around unmaskAsyncExceptions# primop.

maskUninterruptible :: forall a m. MonadUnliftPrim RW m => m a -> m a

A direct wrapper around maskUninterruptible# primop.

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

Eq MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

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

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

Show MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

NFData MaskingState

Since: deepseq-1.4.4.0

Defined in Control.DeepSeq

Methods

rnf :: MaskingState -> ()

getMaskingState :: MonadPrim RW m => m MaskingState

Same as getMaskingState, but generalized to MonadPrim

Since: 0.3.0

Exceptions

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 Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

toException :: Void -> SomeException

fromException :: SomeException -> Maybe Void

displayException :: Void -> String

Exception Timeout

Since: base-4.7.0.0

Defined in System.Timeout

Methods

toException :: Timeout -> SomeException

fromException :: SomeException -> Maybe Timeout

displayException :: Timeout -> String

Exception PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: PatternMatchFail -> SomeException

fromException :: SomeException -> Maybe PatternMatchFail

displayException :: PatternMatchFail -> String

Exception RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecSelError -> SomeException

fromException :: SomeException -> Maybe RecSelError

displayException :: RecSelError -> String

Exception RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecConError -> SomeException

fromException :: SomeException -> Maybe RecConError

displayException :: RecConError -> String

Exception RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecUpdError -> SomeException

fromException :: SomeException -> Maybe RecUpdError

displayException :: RecUpdError -> String

Exception NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NoMethodError -> SomeException

fromException :: SomeException -> Maybe NoMethodError

displayException :: NoMethodError -> 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 NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NonTermination -> SomeException

fromException :: SomeException -> Maybe NonTermination

displayException :: NonTermination -> String

Exception NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NestedAtomically -> SomeException

fromException :: SomeException -> Maybe NestedAtomically

displayException :: NestedAtomically -> 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 Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> 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 CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException

fromException :: SomeException -> Maybe CompactionFailed

displayException :: CompactionFailed -> 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 SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> 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 ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> 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 ExitCode

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException

fromException :: SomeException -> Maybe ExitCode

displayException :: ExitCode -> 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 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

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.

Instances

Show SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Async exceptions

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

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

Show AsyncException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AsyncException -> ShowS

show :: AsyncException -> String

showList :: [AsyncException] -> ShowS

Exception AsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException

fromException :: SomeException -> Maybe AsyncException

displayException :: AsyncException -> String

data SomeAsyncException

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Constructors

Exception e => SomeAsyncException e

Instances

Show SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> SomeAsyncException -> ShowS

show :: SomeAsyncException -> String

showList :: [SomeAsyncException] -> ShowS

Exception SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> String

isSyncException :: Exception e => e -> Bool

isAsyncException :: Exception e => e -> Bool

asyncExceptionToException :: Exception e => e -> SomeException

Since: base-4.7.0.0

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

Since: base-4.7.0.0

Standard exceptions

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

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

Show ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> ErrorCall -> ShowS

show :: ErrorCall -> String

showList :: [ErrorCall] -> ShowS

Exception ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

toException :: ErrorCall -> SomeException

fromException :: SomeException -> Maybe ErrorCall

displayException :: ErrorCall -> String

data ArithException

Arithmetic exceptions.

Constructors

Overflow

Underflow

LossOfPrecision

DivideByZero

Denormal

RatioZeroDenominator

Since: base-4.6.0.0

Instances

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

Show ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> ArithException -> ShowS

show :: ArithException -> String

showList :: [ArithException] -> ShowS

Exception ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException

fromException :: SomeException -> Maybe ArithException

displayException :: ArithException -> String

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

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

Show ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

newtype AssertionFailed

assert was applied to False.

Constructors

AssertionFailed String

Instances

Show AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AssertionFailed -> ShowS

show :: AssertionFailed -> String

showList :: [AssertionFailed] -> ShowS

Exception AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException

fromException :: SomeException -> Maybe AssertionFailed

displayException :: AssertionFailed -> String

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

Eq IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

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

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

Show IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

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

Show NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NonTermination -> ShowS

show :: NonTermination -> String

showList :: [NonTermination] -> ShowS

Exception NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NonTermination -> SomeException

fromException :: SomeException -> Maybe NonTermination

displayException :: NonTermination -> String

data NestedAtomically

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

Constructors

NestedAtomically

Instances

Show NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

showsPrec :: Int -> NestedAtomically -> ShowS

show :: NestedAtomically -> String

showList :: [NestedAtomically] -> ShowS

Exception NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NestedAtomically -> SomeException

fromException :: SomeException -> Maybe NestedAtomically

displayException :: NestedAtomically -> String

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

Show BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS

show :: BlockedIndefinitelyOnMVar -> String

showList :: [BlockedIndefinitelyOnMVar] -> ShowS

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar

displayException :: BlockedIndefinitelyOnMVar -> String

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

Show BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS

show :: BlockedIndefinitelyOnSTM -> String

showList :: [BlockedIndefinitelyOnSTM] -> ShowS

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM

displayException :: BlockedIndefinitelyOnSTM -> String

data AllocationLimitExceeded

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

Since: base-4.8.0.0

Constructors

AllocationLimitExceeded

Instances

Show AllocationLimitExceeded

Since: base-4.7.1.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AllocationLimitExceeded -> ShowS

show :: AllocationLimitExceeded -> String

showList :: [AllocationLimitExceeded] -> ShowS

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException

fromException :: SomeException -> Maybe AllocationLimitExceeded

displayException :: AllocationLimitExceeded -> String

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

Show Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> Deadlock -> ShowS

show :: Deadlock -> String

showList :: [Deadlock] -> ShowS

Exception Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> String

CallStack

data CallStack

CallStacks are a lightweight method of obtaining a partial call-stack at any point in the program.

A function can request its call-site with the HasCallStack constraint. For example, we can define

putStrLnWithCallStack :: HasCallStack => String -> IO ()

as a variant of putStrLn that will get its call-site and print it, along with the string given as argument. We can access the call-stack inside putStrLnWithCallStack with callStack.

putStrLnWithCallStack :: HasCallStack => String -> IO ()
putStrLnWithCallStack msg = do
  putStrLn msg
  putStrLn (prettyCallStack callStack)

Thus, if we call putStrLnWithCallStack we will get a formatted call-stack alongside our string.

>>> putStrLnWithCallStack "hello"
hello
CallStack (from HasCallStack):
  putStrLnWithCallStack, called at <interactive>:2:1 in interactive:Ghci1

GHC solves HasCallStack constraints in three steps:

1. If there is a CallStack in scope -- i.e. the enclosing function has a HasCallStack constraint -- GHC will append the new call-site to the existing CallStack.
2. If there is no CallStack in scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer a HasCallStack constraint for the enclosing definition (subject to the monomorphism restriction).
3. If there is no CallStack in scope and the enclosing definition has an explicit type signature, GHC will solve the HasCallStack constraint for the singleton CallStack containing just the current call-site.

CallStacks do not interact with the RTS and do not require compilation with -prof. On the other hand, as they are built up explicitly via the HasCallStack constraints, they will generally not contain as much information as the simulated call-stacks maintained by the RTS.

A CallStack is a [(String, SrcLoc)]. The String is the name of function that was called, the SrcLoc is the call-site. The list is ordered with the most recently called function at the head.

NOTE: The intrepid user may notice that HasCallStack is just an alias for an implicit parameter ?callStack :: CallStack. This is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.8.1.0

Instances

IsList CallStack

Be aware that 'fromList . toList = id' only for unfrozen CallStacks, since toList removes frozenness information.

Since: base-4.9.0.0

Defined in GHC.Exts

Associated Types

type Item CallStack

Methods

fromList :: [Item CallStack] -> CallStack

fromListN :: Int -> [Item CallStack] -> CallStack

toList :: CallStack -> [Item CallStack]

Show CallStack

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> CallStack -> ShowS

show :: CallStack -> String

showList :: [CallStack] -> ShowS

NFData CallStack

Since: deepseq-1.4.2.0

Defined in Control.DeepSeq

Methods

rnf :: CallStack -> ()

type Item CallStack

Defined in GHC.Exts

type Item CallStack = (String, SrcLoc)

type HasCallStack = ?callStack :: CallStack

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

callStack :: HasCallStack => CallStack

Return the current CallStack.

Does *not* include the call-site of callStack.

Since: base-4.9.0.0

getCallStack :: CallStack -> [([Char], SrcLoc)]

Extract a list of call-sites from the CallStack.

The list is ordered by most recent call.

Since: base-4.8.1.0

prettyCallStack :: CallStack -> String

Pretty print a CallStack.

Since: base-4.9.0.0

data SrcLoc

A single location in the source code.

Since: base-4.8.1.0

Constructors

SrcLoc

Fields

• srcLocPackage :: [Char]
• srcLocModule :: [Char]
• srcLocFile :: [Char]
• srcLocStartLine :: Int
• srcLocStartCol :: Int
• srcLocEndLine :: Int
• srcLocEndCol :: Int

Instances

Eq SrcLoc

Since: base-4.9.0.0

Defined in GHC.Stack.Types

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

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

Show SrcLoc

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

NFData SrcLoc

Since: deepseq-1.4.2.0

Defined in Control.DeepSeq

Methods

rnf :: SrcLoc -> ()

prettySrcLoc :: SrcLoc -> String

Pretty print a SrcLoc.

Since: base-4.9.0.0

module Control.Prim.Monad