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