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

-- | Extensible optionally-pure exceptions
--   
--   Extensible optionally-pure exceptions.
@package exceptions
@version 0.10.9

-- | This module supports monads that can throw extensible exceptions. The
--   exceptions are the very same from Control.Exception, and the
--   operations offered very similar, but here they are not limited to
--   IO.
--   
--   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 ExceptT and MonadError, but
--   based on features of Control.Exception. In particular, it
--   handles the complex case of asynchronous exceptions by including
--   mask in the typeclass. Note that the extensible exceptions
--   feature relies on the RankNTypes language extension.
module Control.Monad.Catch

-- | A class for monads in which exceptions may be thrown.
--   
--   Instances should obey the following law:
--   
--   
--   throwM e >> x = throwM e
--   
--   
--   In other words, throwing an exception short-circuits the rest of the
--   monadic computation.
class Monad m => MonadThrow (m :: Type -> Type)

-- | Throw an exception. Note that this throws when this action is run in
--   the monad m, not when it is applied. It is a generalization
--   of Control.Exception's throwIO.
--   
--   Should satisfy the law:
--   
--   
--   throwM e >> f = throwM e
--   
throwM :: (MonadThrow m, HasCallStack, Exception e) => e -> m a

-- | A class for monads which allow exceptions to be caught, in particular
--   exceptions which were thrown by throwM.
--   
--   Instances should obey the following law:
--   
--   
--   catch (throwM e) f = f e
--   
--   
--   Note that the ability to catch an exception does not guarantee
--   that we can deal with all possible exit points from a computation.
--   Some monads, such as continuation-based stacks, allow for more than
--   just a success/failure strategy, and therefore catch
--   cannot be used by those monads to properly implement a function
--   such as finally. For more information, see MonadMask.
class MonadThrow m => MonadCatch (m :: Type -> Type)

-- | Provide a handler for exceptions thrown during execution of the first
--   action. Note that type of the type of the argument to the handler will
--   constrain which exceptions are caught. See Control.Exception's
--   catch.
catch :: (MonadCatch m, HasCallStack, Exception e) => m a -> (e -> m a) -> m a

-- | A class for monads which provide for the ability to account for all
--   possible exit points from a computation, and to mask asynchronous
--   exceptions. Continuation-based monads are invalid instances of this
--   class.
--   
--   Instances should ensure that, in the following code:
--   
--   
--   fg = f `finally` g
--   
--   
--   The action g is called regardless of what occurs within
--   f, including async exceptions. Some monads allow f
--   to abort the computation via other effects than throwing an exception.
--   For simplicity, we will consider aborting and throwing an exception to
--   be two forms of "throwing an error".
--   
--   If f and g both throw an error, the error thrown by
--   fg depends on which errors we're talking about. In a monad
--   transformer stack, the deeper layers override the effects of the inner
--   layers; for example, ExceptT e1 (Except e2) a represents a
--   value of type Either e2 (Either e1 a), so throwing both an
--   e1 and an e2 will result in Left e2. If
--   f and g both throw an error from the same layer,
--   instances should ensure that the error from g wins.
--   
--   Effects other than throwing an error are also overridden by the deeper
--   layers. For example, StateT s Maybe a represents a value of
--   type s -> Maybe (a, s), so if an error thrown from
--   f causes this function to return Nothing, any
--   changes to the state which f also performed will be erased.
--   As a result, g will see the state as it was before
--   f. Once g completes, f's error will be
--   rethrown, so g' state changes will be erased as well. This is
--   the normal interaction between effects in a monad transformer stack.
--   
--   By contrast, lifted-base's version of finally always
--   discards all of g's non-IO effects, and g never sees
--   any of f's non-IO effects, regardless of the layer ordering
--   and regardless of whether f throws an error. This is not the
--   result of interacting effects, but a consequence of
--   MonadBaseControl's approach.
class MonadCatch m => MonadMask (m :: Type -> Type)

-- | Runs an action with asynchronous exceptions disabled. The action is
--   provided a method for restoring the async. environment to what it was
--   at the mask call. See Control.Exception's mask.
mask :: (MonadMask m, HasCallStack) => ((forall a. () => m a -> m a) -> m b) -> m b

-- | Like mask, but the masked computation is not interruptible (see
--   Control.Exception's uninterruptibleMask. WARNING: Only
--   use if you need to mask exceptions around an interruptible operation
--   AND you can guarantee the interruptible operation will only block for
--   a short period of time. Otherwise you render the program/thread
--   unresponsive and/or unkillable.
uninterruptibleMask :: (MonadMask m, HasCallStack) => ((forall a. () => m a -> m a) -> m b) -> m b

-- | A generalized version of bracket which uses ExitCase to
--   distinguish the different exit cases, and returns the values of both
--   the use and release actions. In practice, this extra
--   information is rarely needed, so it is often more convenient to use
--   one of the simpler functions which are defined in terms of this one,
--   such as bracket, finally, onError, and
--   bracketOnError.
--   
--   This function exists because in order to thread their effects through
--   the execution of bracket, monad transformers need values to be
--   threaded from use to release and from
--   release to the output value.
--   
--   NOTE This method was added in version 0.9.0 of this library.
--   Previously, implementation of functions like bracket and
--   finally in this module were based on the mask and
--   uninterruptibleMask functions only, disallowing some classes of
--   tranformers from having MonadMask instances (notably
--   multi-exit-point transformers like ExceptT). If you are a
--   library author, you'll now need to provide an implementation for this
--   method. The StateT implementation demonstrates most of the
--   subtleties:
--   
--   
--   generalBracket acquire release use = StateT $ \s0 -> do
--     ((b, _s2), (c, s3)) <- generalBracket
--       (runStateT acquire s0)
--       (\(resource, s1) exitCase -> case exitCase of
--         ExitCaseSuccess (b, s2) -> runStateT (release resource (ExitCaseSuccess b)) s2
--   
--         -- In the two other cases, the base monad overrides `use`'s state
--         -- changes and the state reverts to `s1`.
--         ExitCaseException e     -> runStateT (release resource (ExitCaseException e)) s1
--         ExitCaseAbort           -> runStateT (release resource ExitCaseAbort) s1
--       )
--       (\(resource, s1) -> runStateT (use resource) s1)
--     return ((b, c), s3)
--   
--   
--   The StateT s m implementation of generalBracket
--   delegates to the m implementation of generalBracket.
--   The acquire, use, and release arguments
--   given to StateT's implementation produce actions of type
--   StateT s m a, StateT s m b, and StateT s m
--   c. In order to run those actions in the base monad, we need to
--   call runStateT, from which we obtain actions of type m
--   (a, s), m (b, s), and m (c, s). Since each
--   action produces the next state, it is important to feed the state
--   produced by the previous action to the next action.
--   
--   In the ExitCaseSuccess case, the state starts at s0,
--   flows through acquire to become s1, flows through
--   use to become s2, and finally flows through
--   release to become s3. In the other two cases,
--   release does not receive the value s2, so its action
--   cannot see the state changes performed by use. This is fine,
--   because in those two cases, an error was thrown in the base monad, so
--   as per the usual interaction between effects in a monad transformer
--   stack, those state changes get reverted. So we start from s1
--   instead.
--   
--   Finally, the m implementation of generalBracket
--   returns the pairs (b, s) and (c, s). For monad
--   transformers other than StateT, this will be some other type
--   representing the effects and values performed and returned by the
--   use and release actions. The effect part of the
--   use result, in this case _s2, usually needs to be
--   discarded, since those effects have already been incorporated in the
--   release action.
--   
--   The only effect which is intentionally not incorporated in the
--   release action is the effect of throwing an error. In that
--   case, the error must be re-thrown. One subtlety which is easy to miss
--   is that in the case in which use and release both
--   throw an error, the error from release should take priority.
--   Here is an implementation for ExceptT which demonstrates how
--   to do this.
--   
--   
--   generalBracket acquire release use = ExceptT $ do
--     (eb, ec) <- generalBracket
--       (runExceptT acquire)
--       (\eresource exitCase -> case eresource of
--         Left e -> return (Left e) -- nothing to release, `acquire` didn't succeed
--         Right resource -> case exitCase of
--           ExitCaseSuccess (Right b) -> runExceptT (release resource (ExitCaseSuccess b))
--           ExitCaseException e       -> runExceptT (release resource (ExitCaseException e))
--           _                         -> runExceptT (release resource ExitCaseAbort))
--       (either (return . Left) (runExceptT . use))
--     return $ do
--       -- The order in which we perform those two `Either` effects determines
--       -- which error will win if they are both `Left`s. We want the error from
--       -- `release` to win.
--       c <- ec
--       b <- eb
--       return (b, c)
--   
generalBracket :: (MonadMask m, HasCallStack) => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)

-- | A MonadMask computation may either succeed with a value, abort
--   with an exception, or abort for some other reason. For example, in
--   ExceptT e IO you can use throwM to abort with an
--   exception (ExitCaseException) or throwE to abort with a
--   value of type e (ExitCaseAbort).
data ExitCase a
ExitCaseSuccess :: a -> ExitCase a
ExitCaseException :: SomeException -> ExitCase a
ExitCaseAbort :: ExitCase a

-- | Like mask, but does not pass a restore action to the
--   argument.
mask_ :: (HasCallStack, MonadMask m) => m a -> m a

-- | Like uninterruptibleMask, but does not pass a restore
--   action to the argument.
uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a

-- | Catches all exceptions, and somewhat defeats the purpose of the
--   extensible exception system. Use sparingly.
--   
--   NOTE This catches all exceptions, but if the monad
--   supports other ways of aborting the computation, those other kinds of
--   errors will not be caught.
catchAll :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a

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

-- | A more generalized way of determining which exceptions to catch at run
--   time.
catchJust :: (HasCallStack, 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 IOError values in
--   System.IO.Error.
catchIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a

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

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

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

-- | Flipped catchAll
handleAll :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a

-- | Flipped catchIOError
handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a

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

-- | Flipped catchIf
handleIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a

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

-- | A variant of try that takes an exception predicate to select
--   which exceptions are caught. See Control.Exception's
--   tryJust
tryJust :: (HasCallStack, 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.
--   
--   NOTE The action is only run if an exception is thrown.
--   If the monad supports other ways of aborting the computation, the
--   action won't run if those other kinds of errors are thrown. See
--   onError.
onException :: (HasCallStack, MonadCatch m) => m a -> m b -> m a

-- | Run an action only if an error is thrown in the main action. Unlike
--   onException, this works with every kind of error, not just
--   exceptions. For example, if f is an ExceptT
--   computation which aborts with a Left, the computation
--   onError f g will execute g, while onException f
--   g will not.
--   
--   This distinction is only meaningful for monads which have multiple
--   exit points, such as Except and MaybeT. For monads
--   that only have a single exit point, there is no difference between
--   onException and onError, except that onError has
--   a more constrained type.
onError :: (HasCallStack, MonadMask m) => m a -> m b -> m a

-- | Generalized abstracted pattern of safe resource acquisition and
--   release in the face of errors. 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 bracket.
--   
--   If an error is thrown during the use, the release still happens before
--   the error is rethrown.
--   
--   Note that this is essentially a type-specialized version of
--   generalBracket. This function has a more common signature
--   (matching the signature from Control.Exception), and is often
--   more convenient to use. By contrast, generalBracket is more
--   expressive, allowing us to implement other functions like
--   bracketOnError.
bracket :: (HasCallStack, MonadMask m) => m a -> (a -> m c) -> (a -> m b) -> m b

-- | Version of bracket without any value being passed to the second
--   and third actions.
bracket_ :: (HasCallStack, MonadMask m) => m a -> m c -> m b -> m b

-- | Perform an action with a finalizer action that is run, even if an
--   error occurs.
finally :: (HasCallStack, MonadMask m) => m a -> m b -> m a

-- | Like bracket, but only performs the final action if an error is
--   thrown by the in-between computation.
bracketOnError :: (HasCallStack, MonadMask m) => m a -> (a -> m c) -> (a -> m b) -> m b
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e
displayException :: Exception e => e -> String
backtraceDesired :: Exception e => e -> Bool
data SomeException
SomeException :: e -> SomeException
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Functor (Control.Monad.Catch.Handler m)
instance (e GHC.Types.~ GHC.Internal.Exception.Type.SomeException) => Control.Monad.Catch.MonadCatch (GHC.Internal.Data.Either.Either e)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Catch.MonadCatch GHC.Types.IO
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Catch.MonadCatch m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (Control.Monad.Catch.MonadCatch m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Catch.MonadCatch GHC.Internal.Conc.Sync.STM
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.State.Lazy.StateT s m)
instance (Control.Monad.Catch.MonadCatch m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Catch.MonadCatch m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (e GHC.Types.~ GHC.Internal.Exception.Type.SomeException) => Control.Monad.Catch.MonadMask (GHC.Internal.Data.Either.Either e)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Catch.MonadMask GHC.Types.IO
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Catch.MonadMask m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (Control.Monad.Catch.MonadMask m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.State.Lazy.StateT s m)
instance (Control.Monad.Catch.MonadMask m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Catch.MonadMask m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Cont.ContT r m)
instance (e GHC.Types.~ GHC.Internal.Exception.Type.SomeException) => Control.Monad.Catch.MonadThrow (GHC.Internal.Data.Either.Either e)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Catch.MonadThrow GHC.Types.IO
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Catch.MonadThrow []
instance Control.Monad.Catch.MonadThrow GHC.Internal.Maybe.Maybe
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Catch.MonadThrow Language.Haskell.TH.Syntax.Q
instance (Control.Monad.Catch.MonadThrow m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (Control.Monad.Catch.MonadThrow m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Catch.MonadThrow (GHC.Internal.ST.ST s)
instance Control.Monad.Catch.MonadThrow GHC.Internal.Conc.Sync.STM
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.State.Strict.StateT s m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.State.Lazy.StateT s m)
instance (Control.Monad.Catch.MonadThrow m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Catch.MonadThrow m, GHC.Internal.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Control.Monad.Catch.ExitCase a)

-- | This module supplies a 'pure' monad transformer that can be used for
--   mock-testing code that throws exceptions, so long as those exceptions
--   are always thrown with throwM.
--   
--   Do not mix CatchT with IO. Choose one or the other for
--   the bottom of your transformer stack!
module Control.Monad.Catch.Pure

-- | Add Exception handling abilities to a Monad.
--   
--   This should never be used in combination with IO. Think
--   of CatchT as an alternative base monad for use with mocking
--   code that solely throws exceptions via throwM.
--   
--   Note: that IO monad has these abilities already, so stacking
--   CatchT on top of it does not add any value and can possibly be
--   confusing:
--   
--   
--   >>> (error "Hello!" :: IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
--   Hello!
--   
--   
--   
--   >>> runCatchT $ (error "Hello!" :: CatchT IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
--   *** Exception: Hello!
--   
--   
--   
--   >>> runCatchT $ (throwM (ErrorCall "Hello!") :: CatchT IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
--   Hello!
--   
newtype CatchT (m :: Type -> Type) a
CatchT :: m (Either SomeException a) -> CatchT (m :: Type -> Type) a
[runCatchT] :: CatchT (m :: Type -> Type) a -> m (Either SomeException a)
type Catch = CatchT Identity
runCatch :: Catch a -> Either SomeException a

-- | Map the unwrapped computation using the given function.
--   
--   
--   runCatchT (mapCatchT f m) = f (runCatchT m)
--   
mapCatchT :: (m (Either SomeException a) -> n (Either SomeException b)) -> CatchT m a -> CatchT n b
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Alternative (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Data.Foldable.Foldable m => GHC.Internal.Data.Foldable.Foldable (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Functor (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => Control.Monad.Catch.MonadCatch (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Monad.Catch.Pure.CatchT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => Control.Monad.Catch.MonadMask (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.MonadPlus (Control.Monad.Catch.Pure.CatchT m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Catch.Pure.CatchT m)
instance Control.Monad.Reader.Class.MonadReader e m => Control.Monad.Reader.Class.MonadReader e (Control.Monad.Catch.Pure.CatchT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Catch.Pure.CatchT m)
instance GHC.Internal.Base.Monad m => Control.Monad.Catch.MonadThrow (Control.Monad.Catch.Pure.CatchT m)
instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Catch.Pure.CatchT
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Catch.Pure.CatchT m)
instance (GHC.Internal.Base.Monad m, GHC.Internal.Data.Traversable.Traversable m) => GHC.Internal.Data.Traversable.Traversable (Control.Monad.Catch.Pure.CatchT m)
