| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Control.Monad.Class.MonadThrow
Contents
Synopsis
- class Monad m => MonadThrow m where
-
class
MonadThrow
m =>
MonadCatch
m
where
- catch :: Exception e => m a -> (e -> m a) -> m a
- catchJust :: Exception e => (e -> Maybe b) -> m a -> (b -> m a) -> m a
- try :: Exception e => m a -> m ( Either e a)
- tryJust :: Exception e => (e -> Maybe b) -> m a -> m ( Either b a)
- handle :: Exception e => (e -> m a) -> m a -> m a
- handleJust :: Exception e => (e -> Maybe b) -> (b -> m a) -> m a -> m a
- onException :: m a -> m b -> m a
- bracketOnError :: m a -> (a -> m b) -> (a -> m c) -> m c
- generalBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
-
class
MonadCatch
m =>
MonadMask
m
where
- mask , uninterruptibleMask :: (( forall a. m a -> m a) -> m b) -> m b
- mask_ , uninterruptibleMask_ :: m a -> m a
- class MonadMask m => MonadMaskingState m where
-
class
MonadThrow
m =>
MonadEvaluate
m
where
- evaluate :: a -> m a
- data MaskingState
-
class
(
Typeable
e,
Show
e) =>
Exception
e
where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data SomeException
- data ExitCase a
- data Handler m a = forall e. Exception e => Handler (e -> m a)
- catches :: forall m a. MonadCatch m => m a -> [ Handler m a] -> m a
- throwM :: ( MonadThrow m, Exception e) => e -> m a
Documentation
class Monad m => MonadThrow m where Source #
Throwing exceptions, and resource handling in the presence of exceptions.
Does not include the ability to respond to exceptions.
Minimal complete definition
Methods
throwIO :: Exception e => e -> m a Source #
bracket :: m a -> (a -> m b) -> (a -> m c) -> m c Source #
default bracket :: MonadCatch m => m a -> (a -> m b) -> (a -> m c) -> m c Source #
Instances
class MonadThrow m => MonadCatch m where Source #
Catching exceptions.
Covers standard utilities to respond to exceptions.
Minimal complete definition
Methods
catch :: Exception e => m a -> (e -> m a) -> m a Source #
catchJust :: Exception e => (e -> Maybe b) -> m a -> (b -> m a) -> m a Source #
try :: Exception e => m a -> m ( Either e a) Source #
tryJust :: Exception e => (e -> Maybe b) -> m a -> m ( Either b a) Source #
handle :: Exception e => (e -> m a) -> m a -> m a Source #
handleJust :: Exception e => (e -> Maybe b) -> (b -> m a) -> m a -> m a Source #
onException :: m a -> m b -> m a Source #
bracketOnError :: m a -> (a -> m b) -> (a -> m c) -> m c Source #
generalBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c) Source #
General form of bracket
See http://hackage.haskell.org/package/exceptions-0.10.0/docs/Control-Monad-Catch.html#v:generalBracket for discussion and motivation.
default generalBracket :: MonadMask m => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c) Source #
Instances
| MonadCatch IO Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods catch :: Exception e => IO a -> (e -> IO a) -> IO a Source # catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a Source # try :: Exception e => IO a -> IO ( Either e a) Source # tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO ( Either b a) Source # handle :: Exception e => (e -> IO a) -> IO a -> IO a Source # handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a Source # onException :: IO a -> IO b -> IO a Source # bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c Source # generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) Source # |
|
| MonadCatch STM Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods catch :: Exception e => STM a -> (e -> STM a) -> STM a Source # catchJust :: Exception e => (e -> Maybe b) -> STM a -> (b -> STM a) -> STM a Source # try :: Exception e => STM a -> STM ( Either e a) Source # tryJust :: Exception e => (e -> Maybe b) -> STM a -> STM ( Either b a) Source # handle :: Exception e => (e -> STM a) -> STM a -> STM a Source # handleJust :: Exception e => (e -> Maybe b) -> (b -> STM a) -> STM a -> STM a Source # onException :: STM a -> STM b -> STM a Source # bracketOnError :: STM a -> (a -> STM b) -> (a -> STM c) -> STM c Source # generalBracket :: STM a -> (a -> ExitCase b -> STM c) -> (a -> STM b) -> STM (b, c) Source # |
|
| MonadCatch m => MonadCatch ( ExceptT e m) Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods catch :: Exception e0 => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a Source # catchJust :: Exception e0 => (e0 -> Maybe b) -> ExceptT e m a -> (b -> ExceptT e m a) -> ExceptT e m a Source # try :: Exception e0 => ExceptT e m a -> ExceptT e m ( Either e0 a) Source # tryJust :: Exception e0 => (e0 -> Maybe b) -> ExceptT e m a -> ExceptT e m ( Either b a) Source # handle :: Exception e0 => (e0 -> ExceptT e m a) -> ExceptT e m a -> ExceptT e m a Source # handleJust :: Exception e0 => (e0 -> Maybe b) -> (b -> ExceptT e m a) -> ExceptT e m a -> ExceptT e m a Source # onException :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a Source # bracketOnError :: ExceptT e m a -> (a -> ExceptT e m b) -> (a -> ExceptT e m c) -> ExceptT e m c Source # generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) Source # |
|
| MonadCatch m => MonadCatch ( ReaderT r m) Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods catch :: Exception e => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a Source # catchJust :: Exception e => (e -> Maybe b) -> ReaderT r m a -> (b -> ReaderT r m a) -> ReaderT r m a Source # try :: Exception e => ReaderT r m a -> ReaderT r m ( Either e a) Source # tryJust :: Exception e => (e -> Maybe b) -> ReaderT r m a -> ReaderT r m ( Either b a) Source # handle :: Exception e => (e -> ReaderT r m a) -> ReaderT r m a -> ReaderT r m a Source # handleJust :: Exception e => (e -> Maybe b) -> (b -> ReaderT r m a) -> ReaderT r m a -> ReaderT r m a Source # onException :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a Source # bracketOnError :: ReaderT r m a -> (a -> ReaderT r m b) -> (a -> ReaderT r m c) -> ReaderT r m c Source # generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) Source # |
|
| ( MonadSTM m, MonadThrow ( STM m), MonadCatch ( STM m)) => MonadCatch ( WrappedSTM t r m) Source # | |
|
Defined in Control.Monad.Class.MonadSTM Methods catch :: Exception e => WrappedSTM t r m a -> (e -> WrappedSTM t r m a) -> WrappedSTM t r m a Source # catchJust :: Exception e => (e -> Maybe b) -> WrappedSTM t r m a -> (b -> WrappedSTM t r m a) -> WrappedSTM t r m a Source # try :: Exception e => WrappedSTM t r m a -> WrappedSTM t r m ( Either e a) Source # tryJust :: Exception e => (e -> Maybe b) -> WrappedSTM t r m a -> WrappedSTM t r m ( Either b a) Source # handle :: Exception e => (e -> WrappedSTM t r m a) -> WrappedSTM t r m a -> WrappedSTM t r m a Source # handleJust :: Exception e => (e -> Maybe b) -> (b -> WrappedSTM t r m a) -> WrappedSTM t r m a -> WrappedSTM t r m a Source # onException :: WrappedSTM t r m a -> WrappedSTM t r m b -> WrappedSTM t r m a Source # bracketOnError :: WrappedSTM t r m a -> (a -> WrappedSTM t r m b) -> (a -> WrappedSTM t r m c) -> WrappedSTM t r m c Source # generalBracket :: WrappedSTM t r m a -> (a -> ExitCase b -> WrappedSTM t r m c) -> (a -> WrappedSTM t r m b) -> WrappedSTM t r m (b, c) Source # |
|
class MonadCatch m => MonadMask m where Source #
Support for safely working in the presence of asynchronous exceptions.
This is typically not needed directly as the utilities in
MonadThrow
and
MonadCatch
cover most use cases.
Minimal complete definition
Methods
mask :: (( forall a. m a -> m a) -> m b) -> m b Source #
uninterruptibleMask :: (( forall a. m a -> m a) -> m b) -> m b Source #
uninterruptibleMask_ :: m a -> m a Source #
Instances
| MonadMask IO Source # | |
| MonadMask m => MonadMask ( ExceptT e m) Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods mask :: (( forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b Source # uninterruptibleMask :: (( forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b Source # mask_ :: ExceptT e m a -> ExceptT e m a Source # uninterruptibleMask_ :: ExceptT e m a -> ExceptT e m a Source # |
|
| MonadMask m => MonadMask ( ReaderT r m) Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods mask :: (( forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b Source # uninterruptibleMask :: (( forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b Source # mask_ :: ReaderT r m a -> ReaderT r m a Source # uninterruptibleMask_ :: ReaderT r m a -> ReaderT r m a Source # |
|
class MonadMask m => MonadMaskingState m where Source #
Methods
Instances
| MonadMaskingState IO Source # | |
|
Defined in Control.Monad.Class.MonadThrow Methods |
|
class MonadThrow m => MonadEvaluate m where Source #
Monads which can
evaluate
.
Instances
| MonadEvaluate IO Source # | |
|
Defined in Control.Monad.Class.MonadThrow |
|
| MonadEvaluate m => MonadEvaluate ( ReaderT r m) Source # | |
|
Defined in Control.Monad.Class.MonadThrow |
|
data MaskingState Source #
Describes the behaviour of a thread when an asynchronous exception is received.
Constructors
| Unmasked |
asynchronous exceptions are unmasked (the normal state) |
| MaskedInterruptible |
the state during
|
| MaskedUninterruptible |
the state during
|
Instances
| Eq MaskingState |
Since: base-4.3.0.0 |
|
Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool Source # (/=) :: MaskingState -> MaskingState -> Bool Source # |
|
| Show MaskingState |
Since: base-4.3.0.0 |
class ( Typeable e, Show e) => Exception e where Source #
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 Source #
fromException :: SomeException -> Maybe e Source #
displayException :: e -> String Source #
Render this exception value in a human-friendly manner.
Default implementation:
.
show
Since: base-4.8.0.0
Instances
data SomeException Source #
The
SomeException
type is the root of the exception type hierarchy.
When an exception of type
e
is thrown, behind the scenes it is
encapsulated in a
SomeException
.
Instances
| Show SomeException |
Since: base-3.0 |
|
Defined in GHC.Exception.Type |
|
| Exception SomeException |
Since: base-3.0 |
|
Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException Source # fromException :: SomeException -> Maybe SomeException Source # |
|
Used in
generalBracket
See
exceptions
package for discussion and motivation.
Constructors
| ExitCaseSuccess a | |
| ExitCaseException SomeException | |
| ExitCaseAbort |
catches :: forall m a. MonadCatch m => m a -> [ Handler m a] -> m a Source #
Like
catches
but for
MonadCatch
rather than only
IO
.
Deprecated interfaces
throwM :: ( MonadThrow m, Exception e) => e -> m a Source #
Deprecated: Use throwIO