-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | An mtl-compatible monad transformer for unchecked extensible
exceptions.
--   
--   This package provides a monad transformer that allows unchecked
--   extensible exceptions to be thrown and caught.
@package exception-mtl
@version 0.1


module Control.Monad.Exception

-- | Any type that you wish to throw or catch as an exception must be an
--   instance of the <tt>Exception</tt> class. The simplest case is a new
--   exception type directly below the root:
--   
--   <tt> data MyException = ThisException | ThatException deriving (Show,
--   Typeable) instance Exception MyException </tt>
--   
--   The default method definitions in the <tt>Exception</tt> class do what
--   we need in this case. You can now throw and catch
--   <tt>ThisException</tt> and <tt>ThatException</tt> as exceptions:
--   
--   <tt> *Main&gt; throw ThisException catch e -&gt; putStrLn ("Caught "
--   ++ show (e :: MyException)) Caught ThisException </tt>
--   
--   In more complicated examples, you may wish to define a whole hierarchy
--   of exceptions:
--   
--   <tt>
--   ---------------------------------------------------------------------
--   -- Make the root exception type for all the exceptions in a compiler
--   data SomeCompilerException = forall e . Exception e =&gt;
--   SomeCompilerException e deriving Typeable instance Show
--   SomeCompilerException where show (SomeCompilerException e) = show e
--   instance Exception SomeCompilerException compilerExceptionToException
--   :: Exception e =&gt; e -&gt; SomeException
--   compilerExceptionToException = toException . SomeCompilerException
--   compilerExceptionFromException :: Exception e =&gt; SomeException
--   -&gt; Maybe e compilerExceptionFromException x = do
--   SomeCompilerException a &lt;- fromException x cast a
--   ---------------------------------------------------------------------
--   -- Make a subhierarchy for exceptions in the frontend of the compiler
--   data SomeFrontendException = forall e . Exception e =&gt;
--   SomeFrontendException e deriving Typeable instance Show
--   SomeFrontendException where show (SomeFrontendException e) = show e
--   instance Exception SomeFrontendException where toException =
--   compilerExceptionToException fromException =
--   compilerExceptionFromException frontendExceptionToException ::
--   Exception e =&gt; e -&gt; SomeException frontendExceptionToException =
--   toException . SomeFrontendException frontendExceptionFromException ::
--   Exception e =&gt; SomeException -&gt; Maybe e
--   frontendExceptionFromException x = do SomeFrontendException a &lt;-
--   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 </tt>
--   
--   We can now catch a <tt>MismatchedParentheses</tt> exception as
--   <tt>MismatchedParentheses</tt>, <tt>SomeFrontendException</tt> or
--   <tt>SomeCompilerException</tt>, but not other types, e.g.
--   <tt>IOException</tt>:
--   
--   <tt> *Main&gt; throw MismatchedParentheses catch e -&gt; putStrLn
--   ("Caught " ++ show (e :: MismatchedParentheses)) Caught
--   MismatchedParentheses *Main&gt; throw MismatchedParentheses catch e
--   -&gt; putStrLn ("Caught " ++ show (e :: SomeFrontendException)) Caught
--   MismatchedParentheses *Main&gt; throw MismatchedParentheses catch e
--   -&gt; putStrLn ("Caught " ++ show (e :: SomeCompilerException)) Caught
--   MismatchedParentheses *Main&gt; throw MismatchedParentheses catch e
--   -&gt; putStrLn ("Caught " ++ show (e :: IOException)) *** Exception:
--   MismatchedParentheses </tt>
class (Typeable e, Show e) => Exception e
toException :: (Exception e) => e -> SomeException
fromException :: (Exception e) => SomeException -> Maybe e

-- | The <tt>SomeException</tt> type is the root of the exception type
--   hierarchy. When an exception of type <tt>e</tt> is thrown, behind the
--   scenes it is encapsulated in a <tt>SomeException</tt>.
data SomeException :: *
class (Monad m) => MonadException m
throw :: (MonadException m, Exception e) => e -> m a
catch :: (MonadException m, Exception e) => m a -> (e -> m a) -> m a
class (MonadIO m, MonadException m) => MonadIOException m
block :: (MonadIOException m) => m a -> m a
unblock :: (MonadIOException m) => m a -> m a
newtype ExceptionT m a
ExceptionT :: m (Either SomeException a) -> ExceptionT m a
runExceptionT :: ExceptionT m a -> m (Either SomeException a)
mapExceptionT :: (m (Either SomeException a) -> n (Either SomeException b)) -> ExceptionT m a -> ExceptionT n b
liftException :: (MonadException m) => Either SomeException a -> m a
instance (Monoid w, MonadIOException m) => MonadIOException (WriterT w m)
instance (Monoid w, MonadIOException m) => MonadIOException (WriterT w m)
instance (MonadIOException m) => MonadIOException (StateT s m)
instance (MonadIOException m) => MonadIOException (StateT s m)
instance (MonadIOException m) => MonadIOException (ReaderT r m)
instance (Monoid w, MonadIOException m) => MonadIOException (RWST r w s m)
instance (Monoid w, MonadIOException m) => MonadIOException (RWST r w s m)
instance (MonadIOException m) => MonadIOException (ExceptionT m)
instance MonadIOException IO
instance (Monoid w, MonadException m) => MonadException (WriterT w m)
instance (Monoid w, MonadException m) => MonadException (WriterT w m)
instance (MonadException m) => MonadException (StateT s m)
instance (MonadException m) => MonadException (StateT s m)
instance (MonadException m) => MonadException (ReaderT r m)
instance (Monoid w, MonadException m) => MonadException (RWST r w s m)
instance (Monoid w, MonadException m) => MonadException (RWST r w s m)
instance MonadException IO
instance (MonadWriter w m) => MonadWriter w (ExceptionT m)
instance (MonadState s m) => MonadState s (ExceptionT m)
instance (MonadReader r m) => MonadReader r (ExceptionT m)
instance (MonadRWS r w s m) => MonadRWS r w s (ExceptionT m)
instance (MonadCont m) => MonadCont (ExceptionT m)
instance (MonadIO m) => MonadIO (ExceptionT m)
instance MonadTrans ExceptionT
instance (Monad m) => MonadException (ExceptionT m)
instance (MonadFix m) => MonadFix (ExceptionT m)
instance (Monad m) => MonadPlus (ExceptionT m)
instance (Monad m) => Monad (ExceptionT m)
instance (Monad m) => Functor (ExceptionT m)