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:

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
class Typeable (a :: k)
data SomeException = Exception e => SomeException e
data SomeAsyncException = Exception e => SomeAsyncException e
data IOException
assert :: Bool -> a -> a

Throwing

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

Synchronously throw the given exception

Since: 0.1.0.0

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

Synonym for throw

Since: 0.1.0.0

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

Synonym for throw

Since: 0.1.0.0

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

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 Source #

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 Source #
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String #
Show StringException Source #
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 () Source #

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 Source #

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 Source #

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 Source #

catch specialized to only catching IOExceptions

Since: 0.1.3.0

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

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

Flipped version of catch

Since: 0.1.0.0

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

handle specialized to only catching IOExceptions

Since: 0.1.3.0

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

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 Source #

Flipped version of catchDeep

Since: 0.1.1.0

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

Flipped version of catchAnyDeep

Since: 0.1.1.0

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

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 Source #

Flipped catchJust.

Since: 0.1.4.0

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

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) Source #

try specialized to only catching IOExceptions

Since: 0.1.3.0

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

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) Source #

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) Source #

tryDeep specialized to catch all synchronous exceptions

Since: 0.1.1.0

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

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) Source #

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 #

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 Source #

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 Source #

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 Source #

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 Source #

Async safe version of onException

Since: 0.1.0.0

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

Async safe version of bracket

Since: 0.1.0.0

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

Async safe version of bracket_

Since: 0.1.0.0

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

Async safe version of finally

Since: 0.1.0.0

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

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 Source #

Async safe version of bracketOnError

Since: 0.1.0.0

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

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 Source #

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 Source #

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

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

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 Source #

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

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

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 Source #

Check if the given exception is synchronous

Since: 0.1.0.0

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

Check if the given exception is asynchronous

Since: 0.1.0.0

Reexports

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

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]
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
Monad m => MonadThrow (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods throwM :: (HasCallStack, Exception e) => e -> CatchT m a
MonadThrow m => MonadThrow (MaybeT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> MaybeT m a
MonadThrow m => MonadThrow (ExceptT e m)
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) #

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
e ~ SomeException => MonadCatch (Either e)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e0) => Either e a -> (e0 -> Either e a) -> Either e 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
MonadCatch m => MonadCatch (MaybeT m)
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)
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 #

Methods

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) #

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) #
e ~ SomeException => MonadMask (Either e)
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) #
Monad m => MonadMask (CatchT m)
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) #
MonadMask m => MonadMask (MaybeT m)
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)
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 #

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 #

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

Instances

Instances details

Exception NestedAtomically
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Exception NoMatchingContinuationPrompt
Instance details Defined in Control.Exception.Base Methods toException :: NoMatchingContinuationPrompt -> SomeException # fromException :: SomeException -> Maybe NoMatchingContinuationPrompt # displayException :: NoMatchingContinuationPrompt -> String #
Exception NoMethodError
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Exception NonTermination
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Exception PatternMatchFail
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Exception RecConError
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Exception RecSelError
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Exception RecUpdError
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Exception TypeError
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Exception Dynamic
Instance details Defined in Data.Dynamic Methods toException :: Dynamic -> SomeException # fromException :: SomeException -> Maybe Dynamic # displayException :: Dynamic -> String #
Exception Void
Instance details Defined in GHC.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ErrorCall
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Exception ArithException
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception AllocationLimitExceeded
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception ArrayException
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception AssertionFailed
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception AsyncException
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception BlockedIndefinitelyOnMVar
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception CompactionFailed
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Exception Deadlock
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception ExitCode
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception FixIOException
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String #
Exception IOException
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception SomeAsyncException
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Exception IOPortException
Instance details Defined in GHC.IOPort Methods toException :: IOPortException -> SomeException # fromException :: SomeException -> Maybe IOPortException # displayException :: IOPortException -> String #
Exception Timeout
Instance details Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String #
Exception AsyncExceptionWrapper Source #
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String #
Exception StringException Source #
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String #
Exception SyncExceptionWrapper Source #
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String #

class Typeable (a :: k) #

Minimal complete definition

typeRep#

data SomeException #

Constructors

Exception e => SomeException e

Instances

Instances details

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

data SomeAsyncException #

Constructors

Exception e => SomeAsyncException e

Instances

Instances details

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

data IOException #

Instances

Instances details

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

assert :: Bool -> a -> a #