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.

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

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

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.

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

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.

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.

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

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.

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

Since: base-4.7.0.0

Since: base-4.7.0.0

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

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.

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

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

Since: base-4.8.0.0

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

assert was applied to False.

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Asynchronous exceptions.

Exceptions generated by array operations

Allow asynchronous exceptions to be raised even inside mask, making the operation interruptible (see the discussion of "Interruptible operations" in Exception).

When called outside mask, or inside uninterruptibleMask, this function has no effect.

Since: base-4.9.0.0

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

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.

Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.

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

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

Arithmetic exceptions.

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.

Generalized version of throwIO.

Generalized version of ioError.

Generalized version of throwTo.

Generalized version of catch.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of catches.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of Handler.

Generalized version of catchJust.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of handle.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of handleJust.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of try.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of tryJust.

Note, when the given computation throws an exception any monadic side effects in m will be discarded.

Generalized version of evaluate.

Generalized version of mask.

Generalized version of mask_.

Generalized version of uninterruptibleMask.

Generalized version of uninterruptibleMask_.

Generalized version of getMaskingState.

Generalized version of allowInterrupt.

Generalized version of bracket.

Note:

• When the "acquire" or "release" computations throw exceptions any monadic side effects in m will be discarded.
• When the "in-between" computation throws an exception any monadic side effects in m produced by that computation will be discarded but the side effects of the "acquire" or "release" computations will be retained.
• Also, any monadic side effects in m of the "release" computation will be discarded; it is run only for its side effects in IO.

Note that when your acquire and release computations are of type IO it will be more efficient to write:

liftBaseOp (bracket acquire release)

Generalized version of bracket_.

Note any monadic side effects in m of both the "acquire" and "release" computations will be discarded. To keep the monadic side effects of the "acquire" computation, use bracket with constant functions instead.

Note that when your acquire and release computations are of type IO it will be more efficient to write:

liftBaseOp_ (bracket_ acquire release)

Generalized version of bracketOnError.

Note:

• When the "acquire" or "release" computations throw exceptions any monadic side effects in m will be discarded.
• When the "in-between" computation throws an exception any monadic side effects in m produced by that computation will be discarded but the side effects of the "acquire" computation will be retained.
• Also, any monadic side effects in m of the "release" computation will be discarded; it is run only for its side effects in IO.

Note that when your acquire and release computations are of type IO it will be more efficient to write:

liftBaseOp (bracketOnError acquire release)

Generalized version of finally.

Note, any monadic side effects in m of the "afterward" computation will be discarded.

Generalized version of onException.

Note, any monadic side effects in m of the "afterward" computation will be discarded.