Control.Exception.Safe

safe-exceptions-0.1.7.4: Safe, consistent, and easy exception handling

Safe Haskell | Safe-Inferred
Language | Haskell2010

Control.Exception.Safe

Contents

- Throwing
- Catching (with recovery)
- Cleanup (no recovery)
- Coercion to sync and async
- Check exception type
- Reexports

Description

Please see the README.md file in the safe-exceptions repo for information on how to use this module. Relevant links:

- https://github.com/fpco/safe-exceptions#readme
- https://www.stackage.org/package/safe-exceptions

Synopsis

- throw :: (HasCallStack, MonadThrow m, Exception e) => e -> m a
- throwIO :: (HasCallStack, MonadThrow m, Exception e) => e -> m a
- throwM :: (HasCallStack, MonadThrow m, Exception e) => e -> m a
- throwString :: (MonadThrow m, HasCallStack) => String -> m a
- data StringException = StringException String CallStack
- throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m ()
- impureThrow :: (HasCallStack, Exception e) => e -> a
- catch :: (HasCallStack, MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
- catchIO :: (HasCallStack, MonadCatch m) => m a -> (IOException -> m a) -> m a
- catchAny :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a
- catchDeep :: (HasCallStack, MonadCatch m, MonadIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a
- catchAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => m a -> (SomeException -> m a) -> m a
- catchAsync :: (HasCallStack, MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
- catchJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
- handle :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a
- handleIO :: (HasCallStack, MonadCatch m) => (IOException -> m a) -> m a -> m a
- handleAny :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a
- handleDeep :: (HasCallStack, MonadCatch m, Exception e, MonadIO m, NFData a) => (e -> m a) -> m a -> m a
- handleAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => (SomeException -> m a) -> m a -> m a
- handleAsync :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a
- handleJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
- try :: (HasCallStack, MonadCatch m, Exception e) => m a -> m (Either e a)
- tryIO :: (HasCallStack, MonadCatch m) => m a -> m (Either IOException a)
- tryAny :: (HasCallStack, MonadCatch m) => m a -> m (Either SomeException a)
- tryDeep :: (HasCallStack, MonadCatch m, MonadIO m, Exception e, NFData a) => m a -> m (Either e a)
- tryAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => m a -> m (Either SomeException a)
- tryAsync :: (HasCallStack, MonadCatch m, Exception e) => m a -> m (Either e a)
- tryJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
- data Handler (m :: Type -> Type) a = Exception e => Handler (e -> m a)
- catches :: (HasCallStack, MonadCatch m, MonadThrow m) => m a -> [Handler m a] -> m a
- catchesDeep :: (HasCallStack, MonadCatch m, MonadThrow m, MonadIO m, NFData a) => m a -> [Handler m a] -> m a
- catchesAsync :: (HasCallStack, MonadCatch m, MonadThrow m) => m a -> [Handler m a] -> m a
- onException :: (HasCallStack, MonadMask m) => m a -> m b -> m a
- bracket :: (HasCallStack, MonadMask m) => m a -> (a -> m b) -> (a -> m c) -> m c
- bracket_ :: (HasCallStack, MonadMask m) => m a -> m b -> m c -> m c
- finally :: (HasCallStack, MonadMask m) => m a -> m b -> m a
- withException :: (HasCallStack, MonadMask m, Exception e) => m a -> (e -> m b) -> m a
- bracketOnError :: (HasCallStack, MonadMask m) => m a -> (a -> m b) -> (a -> m c) -> m c
- bracketOnError_ :: (HasCallStack, MonadMask m) => m a -> m b -> m c -> m c
- bracketWithError :: (HasCallStack, MonadMask m) => m a -> (Maybe SomeException -> a -> m b) -> (a -> m c) -> m c
- data SyncExceptionWrapper = Exception e => SyncExceptionWrapper e
- toSyncException :: Exception e => e -> SomeException
- data AsyncExceptionWrapper = Exception e => AsyncExceptionWrapper e
- toAsyncException :: Exception e => e -> SomeException
- isSyncException :: Exception e => e -> Bool
- isAsyncException :: Exception e => e -> Bool
- class Monad m => MonadThrow (m :: Type -> Type)
- class MonadThrow m => MonadCatch (m :: Type -> Type)
- class MonadCatch m => MonadMask (m :: Type -> Type) where
  - mask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
  - uninterruptibleMask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
  - generalBracket :: HasCallStack => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
- mask_ :: (HasCallStack, MonadMask m) => m a -> m a
- uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a
- catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a
- handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a
- class (Typeable e, Show e) => Exception e where
  - toException :: e -> SomeException
  - fromException :: SomeException -> Maybe e
  - displayException :: e -> String
  - backtraceDesired :: e -> Bool
- class Typeable (a :: k)
- data SomeException = (Exception e, HasExceptionContext) => SomeException e
- data SomeAsyncException = Exception e => SomeAsyncException e
- data IOException
- assert :: Bool -> a -> a

# Throwing

throw :: (HasCallStack, MonadThrow m, Exception e) => e -> m a #

Synchronously throw the given exception

Since: 0.1.0.0

throwIO :: (HasCallStack, MonadThrow m, Exception e) => e -> m a #

Synonym for `throw`

Since: 0.1.0.0

throwM :: (HasCallStack, MonadThrow m, Exception e) => e -> m a #

Synonym for `throw`

Since: 0.1.0.0

throwString :: (MonadThrow m, HasCallStack) => String -> m a #

A convenience function for throwing a user error. This is useful for cases where it would be too high a burden to define your own exception type.

This throws an exception of type `StringException`. When GHC supports it (base 4.9 and GHC 8.0 and onward), it includes a call stack.

Since: 0.1.5.0

data StringException #

Exception type thrown by `throwString`.

Note that the second field of the data constructor depends on GHC/base version. For base 4.9 and GHC 8.0 and later, the second field is a call stack. Previous versions of GHC and base do not support call stacks, and the field is simply unit (provided to make pattern matching across GHC versions easier).

Since: 0.1.5.0

Constructors

StringException String CallStack |

#### Instances

Instances details

Exception StringException # |
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String # backtraceDesired :: StringException -> Bool #
Show StringException # |
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> StringException -> ShowS # show :: StringException -> String # showList :: [StringException] -> ShowS #

throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m () #

Throw an asynchronous exception to another thread.

Synchronously typed exceptions will be wrapped into an `AsyncExceptionWrapper`, see https://github.com/fpco/safe-exceptions#determining-sync-vs-async

It's usually a better idea to use the async package, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.0.0

impureThrow :: (HasCallStack, Exception e) => e -> a #

Generate a pure value which, when forced, will synchronously throw the given exception

Generally it's better to avoid using this function and instead use `throw`, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.0.0

# Catching (with recovery)

catch :: (HasCallStack, MonadCatch m, Exception e) => m a -> (e -> m a) -> m a #

Same as upstream `catch`, but will not catch asynchronous exceptions

Since: 0.1.0.0

catchIO :: (HasCallStack, MonadCatch m) => m a -> (IOException -> m a) -> m a #

`catch` specialized to only catching `IOException`s

Since: 0.1.3.0

catchAny :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a #

`catch` specialized to catch all synchronous exception

Since: 0.1.0.0

catchDeep :: (HasCallStack, MonadCatch m, MonadIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a #

Same as `catch`, but fully force evaluation of the result value to find all impure exceptions.

Since: 0.1.1.0

catchAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => m a -> (SomeException -> m a) -> m a #

`catchDeep` specialized to catch all synchronous exception

Since: 0.1.1.0

catchAsync :: (HasCallStack, MonadCatch m, Exception e) => m a -> (e -> m a) -> m a #

`catch` without async exception safety

Generally it's better to avoid using this function since we do not want to recover from async exceptions, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.0.0

catchJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a #

`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: 0.1.4.0

handle :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a #

Flipped version of `catch`

Since: 0.1.0.0

handleIO :: (HasCallStack, MonadCatch m) => (IOException -> m a) -> m a -> m a #

`handle` specialized to only catching `IOException`s

Since: 0.1.3.0

handleAny :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a #

Flipped version of `catchAny`

Since: 0.1.0.0

handleDeep :: (HasCallStack, MonadCatch m, Exception e, MonadIO m, NFData a) => (e -> m a) -> m a -> m a #

Flipped version of `catchDeep`

Since: 0.1.1.0

handleAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => (SomeException -> m a) -> m a -> m a #

Flipped version of `catchAnyDeep`

Since: 0.1.1.0

handleAsync :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a #

Flipped version of `catchAsync`

Generally it's better to avoid using this function since we do not want to recover from async exceptions, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.0.0

handleJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a #

Flipped `catchJust`.

Since: 0.1.4.0

try :: (HasCallStack, MonadCatch m, Exception e) => m a -> m (Either e a) #

Same as upstream `try`, but will not catch asynchronous exceptions

Since: 0.1.0.0

tryIO :: (HasCallStack, MonadCatch m) => m a -> m (Either IOException a) #

`try` specialized to only catching `IOException`s

Since: 0.1.3.0

tryAny :: (HasCallStack, MonadCatch m) => m a -> m (Either SomeException a) #

`try` specialized to catch all synchronous exceptions

Since: 0.1.0.0

tryDeep :: (HasCallStack, MonadCatch m, MonadIO m, Exception e, NFData a) => m a -> m (Either e a) #

Same as `try`, but fully force evaluation of the result value to find all impure exceptions.

Since: 0.1.1.0

tryAnyDeep :: (HasCallStack, MonadCatch m, MonadIO m, NFData a) => m a -> m (Either SomeException a) #

`tryDeep` specialized to catch all synchronous exceptions

Since: 0.1.1.0

tryAsync :: (HasCallStack, MonadCatch m, Exception e) => m a -> m (Either e a) #

`try` without async exception safety

Generally it's better to avoid using this function since we do not want to recover from async exceptions, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.0.0

tryJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a) #

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

Since: 0.1.4.0

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 :: (HasCallStack, MonadCatch m, MonadThrow m) => m a -> [Handler m a] -> m a #

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

Since: 0.1.2.0

catchesDeep :: (HasCallStack, MonadCatch m, MonadThrow m, MonadIO m, NFData a) => m a -> [Handler m a] -> m a #

Same as `catches`, but fully force evaluation of the result value to find all impure exceptions.

Since: 0.1.2.0

catchesAsync :: (HasCallStack, MonadCatch m, MonadThrow m) => m a -> [Handler m a] -> m a #

`catches` without async exception safety

Generally it's better to avoid using this function since we do not want to recover from async exceptions, see https://github.com/fpco/safe-exceptions#quickstart

Since: 0.1.2.0

# Cleanup (no recovery)

onException :: (HasCallStack, MonadMask m) => m a -> m b -> m a #

Async safe version of `onException`

Since: 0.1.0.0

bracket :: (HasCallStack, MonadMask m) => m a -> (a -> m b) -> (a -> m c) -> m c #

Async safe version of `bracket`

Since: 0.1.0.0

bracket_ :: (HasCallStack, MonadMask m) => m a -> m b -> m c -> m c #

Async safe version of `bracket_`

Since: 0.1.0.0

finally :: (HasCallStack, MonadMask m) => m a -> m b -> m a #

Async safe version of `finally`

Since: 0.1.0.0

withException :: (HasCallStack, MonadMask m, Exception e) => m a -> (e -> m b) -> m a #

Like `onException`, but provides the handler the thrown exception.

Since: 0.1.0.0

bracketOnError :: (HasCallStack, MonadMask m) => m a -> (a -> m b) -> (a -> m c) -> m c #

Async safe version of `bracketOnError`

Since: 0.1.0.0

bracketOnError_ :: (HasCallStack, MonadMask m) => m a -> m b -> m c -> m c #

A variant of `bracketOnError` where the return value from the first computation is not required.

Since: 0.1.0.0

bracketWithError :: (HasCallStack, MonadMask m) => m a -> (Maybe SomeException -> a -> m b) -> (a -> m c) -> m c #

Async safe version of `bracket` with access to the exception in the cleanup action.

Since: 0.1.7.0

# Coercion to sync and async

data SyncExceptionWrapper #

Wrap up an asynchronous exception to be treated as a synchronous exception

This is intended to be created via `toSyncException`

Since: 0.1.0.0

Constructors

Exception e => SyncExceptionWrapper e |

#### Instances

Instances details

Exception SyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String # backtraceDesired :: SyncExceptionWrapper -> Bool #
Show SyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> SyncExceptionWrapper -> ShowS # show :: SyncExceptionWrapper -> String # showList :: [SyncExceptionWrapper] -> ShowS #

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

Convert an exception into a synchronous exception

For synchronous exceptions, this is the same as `toException`. For asynchronous exceptions, this will wrap up the exception with `SyncExceptionWrapper`

Since: 0.1.0.0

data AsyncExceptionWrapper #

Wrap up a synchronous exception to be treated as an asynchronous exception

This is intended to be created via `toAsyncException`

Since: 0.1.0.0

Constructors

Exception e => AsyncExceptionWrapper e |

#### Instances

Instances details

Exception AsyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String # backtraceDesired :: AsyncExceptionWrapper -> Bool #
Show AsyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> AsyncExceptionWrapper -> ShowS # show :: AsyncExceptionWrapper -> String # showList :: [AsyncExceptionWrapper] -> ShowS #

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

Convert an exception into an asynchronous exception

For asynchronous exceptions, this is the same as `toException`. For synchronous exceptions, this will wrap up the exception with `AsyncExceptionWrapper`

Since: 0.1.0.0

# Check exception type

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

Check if the given exception is synchronous

Since: 0.1.0.0

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

Check if the given exception is asynchronous

Since: 0.1.0.0

# Reexports

class Monad m => MonadThrow (m :: Type -> Type) #

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.

Minimal complete definition

throwM

#### Instances

Instances details

MonadThrow STM |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> STM a #
MonadThrow IO |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> IO a #
MonadThrow Q |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> Q a #
MonadThrow Maybe |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> Maybe a #
MonadThrow [] |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> [a] #
Monad m => MonadThrow (CatchT m) |
Instance details Defined in Control.Monad.Catch.Pure Methods throwM :: (HasCallStack, Exception e) => e -> CatchT m a #
e ~ SomeException => MonadThrow (Either e) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e0) => e0 -> Either e a #
MonadThrow (ST s) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ST s a #
MonadThrow m => MonadThrow (MaybeT m) | Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> MaybeT m a #
MonadThrow m => MonadThrow (ExceptT e m) | Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e0) => e0 -> ExceptT e m a #
MonadThrow m => MonadThrow (IdentityT m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> IdentityT m a #
MonadThrow m => MonadThrow (ReaderT r m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ReaderT r m a #
MonadThrow m => MonadThrow (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> StateT s m a #
MonadThrow m => MonadThrow (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> StateT s m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> WriterT w m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> WriterT w m a #
MonadThrow m => MonadThrow (ContT r m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ContT r m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> RWST r w s m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> RWST r w s m a #

class MonadThrow m => MonadCatch (m :: Type -> Type) #

A class for monads which allow exceptions to be caught, in particular exceptions which were thrown by `throwM`.

Instances should obey the following law:

    catch (throwM e) f = f e

Note that the ability to catch an exception does not guarantee that we can deal with all possible exit points from a computation. Some monads, such as continuation-based stacks, allow for more than just a success/failure strategy, and therefore `catch` cannot be used by those monads to properly implement a function such as `finally`. For more information, see `MonadMask`.

Minimal complete definition

catch

#### Instances

Instances details

MonadCatch STM |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => STM a -> (e -> STM a) -> STM a #
MonadCatch IO |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => IO a -> (e -> IO a) -> IO a #
Monad m => MonadCatch (CatchT m) |
Instance details Defined in Control.Monad.Catch.Pure Methods catch :: (HasCallStack, Exception e) => CatchT m a -> (e -> CatchT m a) -> CatchT m a #
e ~ SomeException => MonadCatch (Either e) | Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e0) => Either e a -> (e0 -> Either e a) -> Either e a #
MonadCatch m => MonadCatch (MaybeT m) | Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadCatch m => MonadCatch (ExceptT e m) | Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e0) => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a #
MonadCatch m => MonadCatch (IdentityT m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadCatch m => MonadCatch (ReaderT r m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
MonadCatch m => MonadCatch (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadCatch m => MonadCatch (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #

class MonadCatch m => MonadMask (m :: Type -> Type) where #

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

    fg = f `finally` g

The action `g` is called regardless of what occurs within `f`, including async exceptions. Some monads allow `f` to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If `f` and `g` both throw an error, the error thrown by `fg` depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, `ExceptT e1 (Except e2) a` represents a value of type `Either e2 (Either e1 a)`, so throwing both an `e1` and an `e2` will result in `Left e2`. If `f` and `g` both throw an error from the same layer, instances should ensure that the error from `g` wins.

Effects other than throwing an error are also overridden by the deeper layers. For example, `StateT s Maybe a` represents a value of type `s -> Maybe (a, s)`, so if an error thrown from `f` causes this function to return `Nothing`, any changes to the state which `f` also performed will be erased. As a result, `g` will see the state as it was before `f`. Once `g` completes, `f`'s error will be rethrown, so `g`' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of `finally` always discards all of `g`'s non-IO effects, and `g` never sees any of `f`'s non-IO effects, regardless of the layer ordering and regardless of whether `f` throws an error. This is not the result of interacting effects, but a consequence of `MonadBaseControl`'s approach.

Methods

mask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b #

Runs an action with asynchronous exceptions disabled. The action is provided a method for restoring the async. environment to what it was at the `mask` call. See Control.Exception's `mask`.

uninterruptibleMask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b #

Like `mask`, but the masked computation is not interruptible (see Control.Exception's `uninterruptibleMask`. WARNING: Only use if you need to mask exceptions around an interruptible operation AND you can guarantee the interruptible operation will only block for a short period of time. Otherwise you render the program/thread unresponsive and/or unkillable.

generalBracket #

Arguments

:: HasCallStack |
=> m a | acquire some resource
-> (a -> ExitCase b -> m c) | release the resource, observing the outcome of the inner action
-> (a -> m b) | inner action to perform with the resource
-> m (b, c) |

A generalized version of `bracket` which uses `ExitCase` to distinguish the different exit cases, and returns the values of both the `use` and `release` actions. In practice, this extra information is rarely needed, so it is often more convenient to use one of the simpler functions which are defined in terms of this one, such as `bracket`, `finally`, `onError`, and `bracketOnError`.

This function exists because in order to thread their effects through the execution of `bracket`, monad transformers need values to be threaded from `use` to `release` and from `release` to the output value.

NOTE This method was added in version 0.9.0 of this library. Previously, implementation of functions like `bracket` and `finally` in this module were based on the `mask` and `uninterruptibleMask` functions only, disallowing some classes of tranformers from having `MonadMask` instances (notably multi-exit-point transformers like `ExceptT`). If you are a library author, you'll now need to provide an implementation for this method. The `StateT` implementation demonstrates most of the subtleties:

    generalBracket acquire release use = StateT $ s0 -> do
      ((b, _s2), (c, s3)) <- generalBracket
        (runStateT acquire s0)
        ((resource, s1) exitCase -> case exitCase of
          ExitCaseSuccess (b, s2) -> runStateT (release resource (ExitCaseSuccess b)) s2

          -- In the two other cases, the base monad overrides use's state
          -- changes and the state reverts to s1.
          ExitCaseException e     -> runStateT (release resource (ExitCaseException e)) s1
          ExitCaseAbort           -> runStateT (release resource ExitCaseAbort) s1
        )
        ((resource, s1) -> runStateT (use resource) s1)
      return ((b, c), s3)

The `StateT s m` implementation of `generalBracket` delegates to the `m` implementation of `generalBracket`. The `acquire`, `use`, and `release` arguments given to `StateT`'s implementation produce actions of type `StateT s m a`, `StateT s m b`, and `StateT s m c`. In order to run those actions in the base monad, we need to call `runStateT`, from which we obtain actions of type `m (a, s)`, `m (b, s)`, and `m (c, s)`. Since each action produces the next state, it is important to feed the state produced by the previous action to the next action.

In the `ExitCaseSuccess` case, the state starts at `s0`, flows through `acquire` to become `s1`, flows through `use` to become `s2`, and finally flows through `release` to become `s3`. In the other two cases, `release` does not receive the value `s2`, so its action cannot see the state changes performed by `use`. This is fine, because in those two cases, an error was thrown in the base monad, so as per the usual interaction between effects in a monad transformer stack, those state changes get reverted. So we start from `s1` instead.

Finally, the `m` implementation of `generalBracket` returns the pairs `(b, s)` and `(c, s)`. For monad transformers other than `StateT`, this will be some other type representing the effects and values performed and returned by the `use` and `release` actions. The effect part of the `use` result, in this case `_s2`, usually needs to be discarded, since those effects have already been incorporated in the `release` action.

The only effect which is intentionally not incorporated in the `release` action is the effect of throwing an error. In that case, the error must be re-thrown. One subtlety which is easy to miss is that in the case in which `use` and `release` both throw an error, the error from `release` should take priority. Here is an implementation for `ExceptT` which demonstrates how to do this.

    generalBracket acquire release use = ExceptT $ do
      (eb, ec) <- generalBracket
        (runExceptT acquire)
        (eresource exitCase -> case eresource of
          Left e -> return (Left e) -- nothing to release, acquire didn't succeed
          Right resource -> case exitCase of
            ExitCaseSuccess (Right b) -> runExceptT (release resource (ExitCaseSuccess b))
            ExitCaseException e       -> runExceptT (release resource (ExitCaseException e))
            _                         -> runExceptT (release resource ExitCaseAbort))
        (either (return . Left) (runExceptT . use))
      return $ do
        -- The order in which we perform those two Either effects determines
        -- which error will win if they are both Lefts. We want the error from
        -- release to win.
        c <- ec
        b <- eb
        return (b, c)

Since: exceptions-0.9.0

#### Instances

Instances details

MonadMask IO |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. IO a -> IO a) -> IO b) -> IO b # uninterruptibleMask :: HasCallStack => ((forall a. IO a -> IO a) -> IO b) -> IO b # generalBracket :: HasCallStack => IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) #
Monad m => MonadMask (CatchT m) | Note: This instance is only valid if the underlying monad has a single exit point! For example, `IO` or `Either` would be invalid base monads, but `Reader` or `State` would be acceptable.
Instance details Defined in Control.Monad.Catch.Pure Methods mask :: HasCallStack => ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b # uninterruptibleMask :: HasCallStack => ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b # generalBracket :: HasCallStack => CatchT m a -> (a -> ExitCase b -> CatchT m c) -> (a -> CatchT m b) -> CatchT m (b, c) #
e ~ SomeException => MonadMask (Either e) | Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # uninterruptibleMask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # generalBracket :: HasCallStack => Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #
MonadMask m => MonadMask (MaybeT m) | Since: exceptions-0.10.0
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # uninterruptibleMask :: HasCallStack => ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # generalBracket :: HasCallStack => MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #
MonadMask m => MonadMask (ExceptT e m) | Since: exceptions-0.9.0
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # uninterruptibleMask :: HasCallStack => ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # generalBracket :: HasCallStack => ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) #
MonadMask m => MonadMask (IdentityT m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # uninterruptibleMask :: HasCallStack => ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # generalBracket :: HasCallStack => IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c) #
MonadMask m => MonadMask (ReaderT r m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # uninterruptibleMask :: HasCallStack => ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # generalBracket :: HasCallStack => ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) #
MonadMask m => MonadMask (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: HasCallStack => StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
MonadMask m => MonadMask (StateT s m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: HasCallStack => StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: HasCallStack => WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: HasCallStack => WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: HasCallStack => RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m) |
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: HasCallStack => RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #

mask_ :: (HasCallStack, MonadMask m) => m a -> m a #

Like `mask`, but does not pass a `restore` action to the argument.

uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a #

Like `uninterruptibleMask`, but does not pass a `restore` action to the argument.

catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a #

Catch all `IOError` (eqv. `IOException`) exceptions. Still somewhat too general, but better than using `catchAll`. See `catchIf` for an easy way of catching specific `IOError`s based on the predicates in System.IO.Error.

handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a #

Flipped `catchIOError`

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 #

`toException` should produce a `SomeException` with no attached `ExceptionContext`.

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

backtraceDesired :: e -> Bool #

#### Instances

Instances details

Exception Timeout | Since: base-4.7.0.0
Instance details Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String # backtraceDesired :: Timeout -> Bool #
Exception Void | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # backtraceDesired :: Void -> Bool #
Exception ErrorCall | @since base-4.0.0.0
Instance details Defined in GHC.Internal.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String # backtraceDesired :: ErrorCall -> Bool #
Exception ArithException | @since base-4.0.0.0
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String # backtraceDesired :: ArithException -> Bool #
Exception SomeException | This drops any attached `ExceptionContext`. @since base-3.0
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Exception AllocationLimitExceeded | @since base-4.8.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String # backtraceDesired :: AllocationLimitExceeded -> Bool #
Exception ArrayException | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String # backtraceDesired :: ArrayException -> Bool #
Exception AssertionFailed | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String # backtraceDesired :: AssertionFailed -> Bool #
Exception AsyncException | @since base-4.7.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String # backtraceDesired :: AsyncException -> Bool #
Exception BlockedIndefinitelyOnMVar | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String # backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool #
Exception BlockedIndefinitelyOnSTM | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String # backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool #
Exception CompactionFailed | @since base-4.10.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String # backtraceDesired :: CompactionFailed -> Bool #
Exception Deadlock | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String # backtraceDesired :: Deadlock -> Bool #
Exception ExitCode | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool #
Exception FixIOException | @since base-4.11.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String # backtraceDesired :: FixIOException -> Bool #
Exception IOException | @since base-4.1.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Exception SomeAsyncException | @since base-4.7.0.0
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool #
Exception AsyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String # backtraceDesired :: AsyncExceptionWrapper -> Bool #
Exception StringException # |
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String # backtraceDesired :: StringException -> Bool #
Exception SyncExceptionWrapper # |
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String # backtraceDesired :: SyncExceptionWrapper -> Bool #
Exception a => Exception (ExceptionWithContext a) |
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException # fromException :: SomeException -> Maybe (ExceptionWithContext a) # displayException :: ExceptionWithContext a -> String # backtraceDesired :: ExceptionWithContext a -> Bool #
Exception e => Exception (NoBacktrace e) |
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException # fromException :: SomeException -> Maybe (NoBacktrace e) # displayException :: NoBacktrace e -> String # backtraceDesired :: NoBacktrace e -> Bool #

class Typeable (a :: k) #

The class `Typeable` allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

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, HasExceptionContext) => SomeException e |

#### Instances

Instances details

Exception SomeException | This drops any attached `ExceptionContext`. @since base-3.0
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Show SomeException | Since: ghc-internal-3.0
Instance details Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #

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

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.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Show IOException | @since base-4.1.0.0
Instance details Defined in GHC.Internal.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.Internal.IO.Exception Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #

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.