Synchronously throw the given exception.

Since: unliftio-0.1.0.0

A class for monads in which exceptions may be thrown.

Instances should obey the following law:

throwM e >> x = throwM e

In other words, throwing an exception short-circuits the rest of the monadic computation.

Raise an IOError in the IO monad.

Construct an IOError value with a string describing the error. The fail method of the IO instance of the Monad class raises a userError, thus:

instance Monad IO where
  ...
  fail s = ioError (userError s)

Computation exitWith code throws ExitCode code. Normally this terminates the program, returning code to the program's caller.

On program termination, the standard Handles stdout and stderr are flushed automatically; any other buffered Handles need to be flushed manually, otherwise the buffered data will be discarded.

A program that fails in any other way is treated as if it had called exitFailure. A program that terminates successfully without calling exitWith explicitly is treated as if it had called exitWith ExitSuccess.

As an ExitCode is not an IOError, exitWith bypasses the error handling in the IO monad and cannot be intercepted by catch from the Prelude. However it is a SomeException, and can be caught using the functions of Control.Exception. This means that cleanup computations added with bracket (from Control.Exception) are also executed properly on exitWith.

Note: in GHC, exitWith should be called from the main program thread in order to exit the process. When called from another thread, exitWith will throw an ExitException as normal, but the exception will not cause the process itself to exit.

The computation exitFailure is equivalent to exitWith (ExitFailure exitfail), where exitfail is implementation-dependent.

The computation exitSuccess is equivalent to exitWith ExitSuccess, It terminates the program successfully.

Write given error message to stderr and terminate with exitFailure.

Since: base-4.8.0.0

Unlifted catch, but will not catch asynchronous exceptions.

Since: unliftio-0.1.0.0

catch specialized to catch all synchronous exception.

Since: unliftio-0.1.0.0

Same as upstream catches, but will not catch asynchronous exceptions.

Since: unliftio-0.1.0.0

Generalized version of Handler.

Since: unliftio-0.1.0.0

catchJust is like catch but it takes an extra argument which is an exception predicate, a function which selects which type of exceptions we're interested in.

Since: unliftio-0.1.0.0

Flipped version of catch.

Since: unliftio-0.1.0.0

Flipped catchJust.

Since: unliftio-0.1.0.0

Unlifted try, but will not catch asynchronous exceptions.

Since: unliftio-0.1.0.0

try specialized to catch all synchronous exceptions.

Since: unliftio-0.1.0.0

A variant of try that takes an exception predicate to select which exceptions are caught.

Since: unliftio-0.1.0.0

try specialized to only catching IOExceptions.

Since: unliftio-0.1.0.0

Async safe version of bracket.

Since: unliftio-0.1.0.0

Async safe version of bracket_.

Since: unliftio-0.1.0.0

Async safe version of bracketOnError.

Since: unliftio-0.1.0.0

Async safe version of finally.

Since: unliftio-0.1.0.0

Async safe version of onException.

Since: unliftio-0.1.0.0

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

Unlifted version of mask.

Since: unliftio-0.1.0.0

Unlifted version of mask_.

Since: unliftio-0.1.0.0

Unlifted version of uninterruptibleMask.

Since: unliftio-0.1.0.0

Unlifted version of uninterruptibleMask_.

Since: unliftio-0.1.0.0

Returns the MaskingState for the current thread.

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

When invoked inside mask, this function allows a masked asynchronous exception to be raised, if one exists. It is equivalent to performing an interruptible operation (see #interruptible), but does not involve any actual blocking.

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

Since: base-4.4.0.0

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.

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

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

Defines the exit codes that a program can return.

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.

Superclass for asynchronous exceptions.

Since: base-4.7.0.0

Asynchronous exceptions.

Since: base-4.7.0.0

Since: base-4.7.0.0