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


-- | Extensible optionally-pure exceptions
--   
--   Extensible optionally-pure exceptions
@package exceptions
@version 0.1


-- | This module supports monads that can throw extensible exceptions. The
--   exceptions are the very same from <a>Control.Exception</a>, and the
--   operations offered very similar, but here they are not limited to
--   <a>IO</a>.
--   
--   This code is in the style of both transformers and mtl, and is
--   compatible with them, though doesn't mimic the module structure or
--   offer the complete range of features in those packages.
--   
--   This is very similar to <tt>ErrorT</tt> and <tt>MonadError</tt>, but
--   based on features of <a>Control.Exception</a>. In particular, it
--   handles the complex case of asynchronous exceptions by including
--   <a>mask</a> in the typeclass. Note that the extensible extensions
--   feature relies the RankNTypes language extension.
module Control.Monad.Catch
class Monad m => MonadCatch m
throwM :: (MonadCatch m, Exception e) => e -> m a
catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
mask :: MonadCatch m => ((forall a. m a -> m a) -> m b) -> m b

-- | Add <a>Exception</a> handling abilities to a <a>Monad</a>.
newtype CatchT m a
CatchT :: m (Either SomeException a) -> CatchT m a
runCatchT :: CatchT m a -> m (Either SomeException a)
type Catch = CatchT Identity
runCatch :: Catch a -> Either SomeException a

-- | Map the unwrapped computation using the given function.
--   
--   <ul>
--   <li><tt><tt>runErrorT</tt> (<tt>mapErrorT</tt> f m) = f
--   (<tt>runErrorT</tt> m</tt>)</li>
--   </ul>
mapCatchT :: (m (Either SomeException a) -> n (Either SomeException b)) -> CatchT m a -> CatchT n b

-- | Catches all exceptions, and somewhat defeats the purpose of the
--   extensible exception system. Use sparingly.
catchAll :: MonadCatch m => m a -> (SomeException -> m a) -> m a

-- | Catch all <a>IOError</a> (eqv. <tt>IOException</tt>) exceptions. Still
--   somewhat too general, but better than using <a>catchAll</a>. See
--   <a>catchIf</a> for an easy way of catching specific <a>IOError</a>s
--   based on the predicates in <a>System.IO.Error</a>.
catchIOError :: MonadCatch m => m a -> (IOError -> m a) -> m a

-- | A more generalized way of determining which exceptions to catch at run
--   time.
catchJust :: (MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a

-- | Catch exceptions only if they pass some predicate. Often useful with
--   the predicates for testing <a>IOError</a> values in
--   <a>System.IO.Error</a>.
catchIf :: (MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a

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

-- | Catches different sorts of exceptions. See <a>Control.Exception</a>'s
--   <a>catches</a>
catches :: (Foldable f, MonadCatch m) => m a -> f (Handler m a) -> m a

-- | Flipped <a>catch</a>. See <a>Control.Exception</a>'s <a>handle</a>.
handle :: (MonadCatch m, Exception e) => (e -> m a) -> m a -> m a

-- | Flipped <a>catchJust</a>. See <a>Control.Exception</a>'s
--   <a>handleJust</a>.
handleJust :: (MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a

-- | Similar to <a>catch</a>, but returns an <a>Either</a> result. See
--   <a>Control.Exception</a>'s <a>try</a>.
try :: (MonadCatch m, Exception e) => m a -> m (Either e a)

-- | A variant of <a>try</a> that takes an exception predicate to select
--   which exceptions are caught. See <a>Control.Exception</a>'s
--   <a>tryJust</a>
tryJust :: (MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)

-- | Run an action only if an exception is thrown in the main action. The
--   exception is not caught, simply rethrown.
onException :: MonadCatch m => m a -> m b -> m a

-- | Generalized abstracted pattern of safe resource acquisition and
--   release in the face of exceptions. The first action "acquires" some
--   value, which is "released" by the second action at the end. The third
--   action "uses" the value and its result is the result of the
--   <a>bracket</a>.
--   
--   If an exception occurs during the use, the release still happens
--   before the exception is rethrown.
bracket :: MonadCatch m => m a -> (a -> m b) -> (a -> m c) -> m c

-- | Version of <a>bracket</a> without any value being passed to the second
--   and third actions.
bracket_ :: MonadCatch m => m a -> m b -> m c -> m c

-- | Perform an action with a finalizer action that is run, even if an
--   exception occurs.
finally :: MonadCatch m => m a -> m b -> m a

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

-- | 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:
--   
--   <pre>
--   data MyException = ThisException | ThatException
--       deriving (Show, Typeable)
--   
--   instance Exception MyException
--   </pre>
--   
--   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:
--   
--   <pre>
--   *Main&gt; throw ThisException `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: MyException))
--   Caught ThisException
--   </pre>
--   
--   In more complicated examples, you may wish to define a whole hierarchy
--   of exceptions:
--   
--   <pre>
--   ---------------------------------------------------------------------
--   -- 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
--   </pre>
--   
--   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>:
--   
--   <pre>
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: SomeFrontendException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: SomeCompilerException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses <tt>catch</tt> e -&gt; putStrLn ("Caught " ++ show (e :: IOException))
--   *** Exception: MismatchedParentheses
--   </pre>
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 :: *
SomeException :: e -> SomeException
instance Monad m => Functor (Handler m)
instance MonadRWS r w s m => MonadRWS r w s (CatchT m)
instance MonadWriter w m => MonadWriter w (CatchT m)
instance MonadReader e m => MonadReader e (CatchT m)
instance MonadState s m => MonadState s (CatchT m)
instance Monad m => MonadCatch (CatchT m)
instance MonadIO m => MonadIO (CatchT m)
instance MonadTrans CatchT
instance Monad m => MonadPlus (CatchT m)
instance Monad m => Alternative (CatchT m)
instance (Monad m, Traversable m) => Traversable (CatchT m)
instance Foldable m => Foldable (CatchT m)
instance MonadFix m => MonadFix (CatchT m)
instance Monad m => Monad (CatchT m)
instance Monad m => Applicative (CatchT m)
instance Monad m => Functor (CatchT m)
instance (MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
instance (MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
instance (MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
instance (MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
instance MonadCatch m => MonadCatch (ReaderT r m)
instance MonadCatch m => MonadCatch (StateT s m)
instance MonadCatch m => MonadCatch (StateT s m)
instance MonadCatch m => MonadCatch (IdentityT m)
instance MonadCatch IO