control-monad-exception-0.4.5: Explicitly typed, checked exceptions with stack traces

Control.Monad.Exception.Class

Synopsis

Documentation

class Monad m => MonadThrow e m whereSource

Methods

throw :: e -> m aSource

throwWithSrcLoc :: String -> e -> m aSource

Instances

Exception e => MonadThrow e IO 
MonadThrow e m => MonadThrow e (ListT m) 
Error e => MonadThrow e (Either e) 
MonadThrow e m => MonadThrow e (StateT s m) 
(Monoid w, MonadThrow e m) => MonadThrow e (WriterT w m) 
MonadThrow e m => MonadThrow e (ReaderT r m) 
(Error e, Monad m) => MonadThrow e (ErrorT e m) 
(Exception e, Throws e l, Monad m) => MonadThrow e (EMT l m) 
(Monoid w, MonadThrow e m) => MonadThrow e (RWST r w s m) 

class (Monad m, Monad m') => MonadCatch e m m' | e m -> m', e m' -> m whereSource

Methods

catch :: m a -> (e -> m' a) -> m' aSource

catchWithSrcLoc :: m a -> ([String] -> e -> m' a) -> m' aSource

Instances

Exception e => MonadCatch e IO IO 
MonadCatch e m m' => MonadCatch e (ListT m) (ListT m') 
Error e => MonadCatch e (Either e) (Either e) 
MonadCatch e m m' => MonadCatch e (StateT s m) (StateT s m') 
(Monoid w, MonadCatch e m m') => MonadCatch e (WriterT w m) (WriterT w m') 
MonadCatch e m m' => MonadCatch e (ReaderT r m) (ReaderT r m') 
(Error e, Monad m) => MonadCatch e (ErrorT e m) (ErrorT e m) 
(Exception e, Monad m) => MonadCatch e (EMT (Caught e l) m) (EMT l m) 
(Monoid w, MonadCatch e m m') => MonadCatch e (RWST r w s m) (RWST r w s m') 

class (Private l, Exception e) => Throws e l Source

Throws is the mechanism used to keep a type level list of exceptions.

Usually there is no need for the user of this library to add further instances to Throws except in one case: to encode subtyping. For instance if we have an IOException type and a FIleNotFoundException subcase, we need to add the instance:

 instance Throws FileNotFoundException (Caught IOException l)

Instances

UncaughtException e => Throws e NoExceptions 
Exception e => Throws e (Caught SomeException l)

SomeException is at the top of the exception hierarchy . Capturing SomeException captures every possible exception

Throws e l => Throws e (Caught e' l) 
Exception e => Throws e (Caught e l) 

data Caught e l Source

A type level witness of a exception handler.

Instances

Exception e => Throws e (Caught SomeException l)

SomeException is at the top of the exception hierarchy . Capturing SomeException captures every possible exception

Throws e l => Throws e (Caught e' l) 
Exception e => Throws e (Caught e l) 
(Exception e, Monad m) => MonadCatch e (EMT (Caught e l) m) (EMT l m) 
Private (Caught e l) 

newtype WrapException l Source

WrapException adds a phantom type parameter l to SomeException

Constructors

WrapException 

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, Typeable) 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 deriving Typeable 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 deriving Typeable 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 (Typeable, 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

data SomeException where

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

SomeException :: Exception e => e -> SomeException 

Instances

Show SomeException 
Typeable SomeException 
Exception SomeException 
Exception e => Throws e (Caught SomeException l)

SomeException is at the top of the exception hierarchy . Capturing SomeException captures every possible exception

class Exception e => UncaughtException e Source

Uncaught Exceptions model unchecked exceptions (a la RuntimeException in Java)

In order to declare an unchecked exception e, all that is needed is to make e an instance of UncaughtException

data ParanoidMode Source

Instances

Private ParanoidMode