Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
A generalisation of
Control.Exception
API to both IO
and IOSim.
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
- getMaskingState :: m MaskingState
- interruptible :: m a -> m a
- allowInterrupt :: m ()
- 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
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.
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
MonadThrow STM Source # | |
MonadThrow IO Source # | |
MonadThrow m => MonadThrow (ReaderT r m) Source # | |
Defined in Control.Monad.Class.MonadThrow throwIO :: Exception e => e -> ReaderT r m a Source # bracket :: ReaderT r m a -> (a -> ReaderT r m b) -> (a -> ReaderT r m c) -> ReaderT r m c Source # bracket_ :: ReaderT r m a -> ReaderT r m b -> ReaderT r m c -> ReaderT r m c Source # finally :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a Source # |
class MonadThrow m => MonadCatch m where Source #
Catching exceptions.
Covers standard utilities to respond to exceptions.
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
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.
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 (ReaderT r m) Source # | |
Defined in Control.Monad.Class.MonadThrow 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 #
getMaskingState :: m MaskingState Source #
interruptible :: m a -> m a Source #
allowInterrupt :: m () Source #
Instances
MonadMaskingState IO Source # | |
Defined in Control.Monad.Class.MonadThrow getMaskingState :: IO MaskingState Source # interruptible :: IO a -> IO a Source # allowInterrupt :: IO () Source # |
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 #
Describes the behaviour of a thread when an asynchronous exception is received.
Unmasked | asynchronous exceptions are unmasked (the normal state) |
MaskedInterruptible | the state during |
MaskedUninterruptible | the state during |
Instances
Show MaskingState | Since: base-4.3.0.0 |
Defined in GHC.IO showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS # | |
NFData MaskingState | Since: deepseq-1.4.4.0 |
Defined in Control.DeepSeq rnf :: MaskingState -> () # | |
Eq MaskingState | Since: base-4.3.0.0 |
Defined in GHC.IO (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool # |
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
Nothing
toException :: e -> SomeException #
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
Instances
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
.
Instances
Exception SomeException | Since: base-3.0 |
Defined in GHC.Exception.Type | |
Show SomeException | Since: base-3.0 |
Defined in GHC.Exception.Type showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS # |
Used in generalBracket
See exceptions
package for discussion and motivation.
catches :: forall m a. MonadCatch m => m a -> [Handler m a] -> m a Source #
Like catches
but for MonadCatch
rather than only IO
.