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

-- | Monad-transformer version of the Control.Exception module
--   
--   Provides a monad-transformer version of the
--   Control.Exception.catch function. For this, it defines the
--   MonadCatchIO class, a subset of MonadIO. It defines
--   proper instances for most monad transformers in the mtl
--   library.
@package MonadCatchIO-mtl
@version 0.3.0.5

module Control.Monad.CatchIO
class MonadIO m => MonadCatchIO m
catch :: (MonadCatchIO m, Exception e) => m a -> (e -> m a) -> m a
block :: MonadCatchIO m => m a -> m a
unblock :: MonadCatchIO m => m a -> m a

-- | 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
--   
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e

-- | Generalized version of throwIO
throw :: (MonadIO m, Exception e) => e -> m a

-- | Generalized version of try
try :: (MonadCatchIO m, Exception e) => m a -> m (Either e a)

-- | Generalized version of tryJust
tryJust :: (MonadCatchIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)

-- | Generalized version of onException
onException :: MonadCatchIO m => m a -> m b -> m a

-- | Generalized version of bracket
bracket :: MonadCatchIO m => m a -> (a -> m b) -> (a -> m c) -> m c

-- | A variant of bracket where the return value from the first
--   computation is not required.
bracket_ :: MonadCatchIO m => m a -> m b -> m c -> m c

-- | A specialised variant of bracket with just a computation to run
--   afterward.
finally :: MonadCatchIO m => m a -> m b -> m a

-- | Like bracket, but only performs the final action if there was
--   an exception raised by the in-between computation.
bracketOnError :: MonadCatchIO m => m a -> (a -> m b) -> (a -> m c) -> m c

-- | Generalized version of Handler
data Handler m a
Handler :: (e -> m a) -> Handler m a

-- | Generalized version of catches
catches :: MonadCatchIO m => m a -> [Handler m a] -> m a
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m)
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (WriterT w m)
instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m)
instance MonadCatchIO m => MonadCatchIO (StateT s m)
instance MonadCatchIO m => MonadCatchIO (ReaderT r m)
instance MonadCatchIO IO
