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

-- | Lift control operations, like exception catching, through monad transformers
--   
--   This package defines the type class MonadBaseControl, a
--   subset of MonadBase into which generic control operations
--   such as catch can be lifted from IO or any other
--   base monad. Instances are based on monad transformers in
--   MonadTransControl, which includes all standard monad
--   transformers in the transformers library except
--   ContT.
--   
--   See the lifted-base package which uses monad-control
--   to lift IO operations from the base library (like
--   catch or bracket) into any monad that is an instance
--   of MonadBase or MonadBaseControl.
--   
--   Note that this package is a rewrite of Anders Kaseorg's
--   monad-peel library. The main difference is that this package
--   provides CPS style operators and exploits the RankNTypes and
--   TypeFamilies language extensions to simplify and speedup most
--   definitions.
@package monad-control
@version 1.0.3.1

-- | This module defines the type class MonadBaseControl, a subset
--   of MonadBase into which generic control operations such as
--   catch can be lifted from IO or any other base monad.
--   Instances are based on monad transformers in MonadTransControl,
--   which includes all standard monad transformers in the
--   transformers library except ContT.
--   
--   See the lifted-base package which uses monad-control
--   to lift IO operations from the base library (like
--   catch or bracket) into any monad that is an instance
--   of MonadBase or MonadBaseControl.
--   
--   See the following tutorial by Michael Snoyman on how to use this
--   package:
--   
--   https://www.yesodweb.com/book/monad-control
--   
--   
Quick implementation guide
--   
--   Given a base monad B and a stack of transformers T:
--   
--   
--   
- Define instances MonadTransControl T for all
--   transformers T, using the defaultLiftWith and
--   defaultRestoreT functions on the constructor and
--   deconstructor of T.
--   
- Define an instance MonadBaseControl B B for the
--   base monad:
instance MonadBaseControl B B where type StM B a = a
--   liftBaseWith f = f id restoreM = return 

--   
- Define instances MonadBaseControl B m =>
--   MonadBaseControl B (T m) for all
--   transformers:
instance MonadBaseControl b m => MonadBaseControl
--   b (T m) where type StM (T m) a = ComposeSt T m a liftBaseWith f
--   = defaultLiftBaseWith restoreM = defaultRestoreM
--   

--   
module Control.Monad.Trans.Control

-- | The MonadTransControl type class is a stronger version of
--   MonadTrans:
--   
--   Instances of MonadTrans know how to
--   lift actions in the base monad to the transformed
--   monad. These lifted actions, however, are completely unaware of the
--   monadic state added by the transformer.
--   
--   MonadTransControl instances are aware of the monadic
--   state of the transformer and allow to save and restore this state.
--   
--   This allows to lift functions that have a monad transformer in both
--   positive and negative position. Take, for example, the function
--   
--   
--   withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
--   
--   
--   MonadTrans instances can only lift the return type of
--   the withFile function:
--   
--   
--   withFileLifted :: MonadTrans t => FilePath -> IOMode -> (Handle -> IO r) -> t IO r
--   withFileLifted file mode action = lift (withFile file mode action)
--   
--   
--   However, MonadTrans is not powerful enough to make
--   withFileLifted accept a function that returns t IO.
--   The reason is that we need to take away the transformer layer in order
--   to pass the function to withFile.
--   MonadTransControl allows us to do this:
--   
--   
--   withFileLifted' :: (Monad (t IO), MonadTransControl t) => FilePath -> IOMode -> (Handle -> t IO r) -> t IO r
--   withFileLifted' file mode action = liftWith (\run -> withFile file mode (run . action)) >>= restoreT . return
--   
class MonadTrans t => MonadTransControl (t :: Type -> Type -> Type -> Type) where {
    
    -- | Monadic state of <tt>t</tt>.
    --   
    --   The monadic state of a monad transformer is the result type of its
    --   <tt>run</tt> function, e.g.:
    --   
    --   <pre>
    --   <a>runReaderT</a> :: <a>ReaderT</a> r m a -&gt; r -&gt; m a
    --   <a>StT</a> (<a>ReaderT</a> r) a ~ a
    --   
    --   <a>runStateT</a> :: <a>StateT</a> s m a -&gt; s -&gt; m (a, s)
    --   <a>StT</a> (<a>StateT</a> s) a ~ (a, s)
    --   
    --   <a>runMaybeT</a> :: <a>MaybeT</a> m a -&gt; m (<a>Maybe</a> a)
    --   <a>StT</a> <a>MaybeT</a> a ~ <a>Maybe</a> a
    --   </pre>
    --   
    --   Provided type instances:
    --   
    --   <pre>
    --   StT <a>IdentityT</a>    a ~ a
    --   StT <a>MaybeT</a>       a ~ <a>Maybe</a> a
    --   StT (<tt>ErrorT</tt> e)   a ~ <tt>Error</tt> e =&gt; <a>Either</a> e a
    --   StT (<a>ExceptT</a> e)  a ~ <a>Either</a> e a
    --   StT <tt>ListT</tt>        a ~ [a]
    --   StT (<a>ReaderT</a> r)  a ~ a
    --   StT (<a>StateT</a> s)   a ~ (a, s)
    --   StT (<a>WriterT</a> w)  a ~ <a>Monoid</a> w =&gt; (a, w)
    --   StT (<a>RWST</a> r w s) a ~ <a>Monoid</a> w =&gt; (a, s, w)
    --   </pre>
    type StT (t :: Type -> Type -> Type -> Type) a;
}

-- | liftWith is similar to lift in that it lifts a
--   computation from the argument monad to the constructed monad.
--   
--   Instances should satisfy similar laws as the MonadTrans laws:
--   
--   
--   liftWith (\_ -> return a) = return a
--   
--   
--   
--   liftWith (\_ -> m >>= f)  =  liftWith (\_ -> m) >>= (\a -> liftWith (\_ -> f a))
--   
--   
--   The difference with lift is that before lifting the
--   m computation liftWith captures the state of
--   t. It then provides the m computation with a
--   Run function that allows running t n computations in
--   n (for all n) on the captured state, e.g.
--   
--   
--   withFileLifted :: (Monad (t IO), MonadTransControl t) => FilePath -> IOMode -> (Handle -> t IO r) -> t IO r
--   withFileLifted file mode action = liftWith (\run -> withFile file mode (run . action)) >>= restoreT . return
--   
--   
--   If the Run function is ignored, liftWith coincides
--   with lift:
--   
--   
--   lift f = liftWith (\_ -> f)
--   
--   
--   Implementations use the Run function associated with a
--   transformer:
--   
--   
--   liftWith :: Monad m => ((Monad n => ReaderT r n b -> n b) -> m a) -> ReaderT r m a
--   liftWith f = ReaderT (\r -> f (\action -> runReaderT action r))
--   
--   liftWith :: Monad m => ((Monad n => StateT s n b -> n (b, s)) -> m a) -> StateT s m a
--   liftWith f = StateT (\s -> liftM (\x -> (x, s)) (f (\action -> runStateT action s)))
--   
--   liftWith :: Monad m => ((Monad n => MaybeT n b -> n (Maybe b)) -> m a) -> MaybeT m a
--   liftWith f = MaybeT (liftM Just (f runMaybeT))
--   
liftWith :: (MonadTransControl t, Monad m) => (Run t -> m a) -> t m a

-- | Construct a t computation from the monadic state of
--   t that is returned from a Run function.
--   
--   Instances should satisfy:
--   
--   
--   liftWith (\run -> run t) >>= restoreT . return = t
--   
--   
--   restoreT is usually implemented through the constructor of
--   the monad transformer:
--   
--   
--   ReaderT  :: (r -> m a) -> ReaderT r m a
--   restoreT ::       m a  -> ReaderT r m a
--   restoreT action = ReaderT { runReaderT = const action }
--   
--   StateT   :: (s -> m (a, s)) -> StateT s m a
--   restoreT ::       m (a, s)  -> StateT s m a
--   restoreT action = StateT { runStateT = const action }
--   
--   MaybeT   :: m (Maybe a) -> MaybeT m a
--   restoreT :: m (Maybe a) -> MaybeT m a
--   restoreT action = MaybeT action
--   
--   
--   Example type signatures:
--   
--   
--   restoreT :: Monad m             => m a            -> IdentityT m a
--   restoreT :: Monad m             => m (Maybe a)    -> MaybeT m a
--   restoreT :: (Monad m, Error e)  => m (Either e a) -> ErrorT e m a
--   restoreT :: Monad m             => m (Either e a) -> ExceptT e m a
--   restoreT :: Monad m             => m [a]          -> ListT m a
--   restoreT :: Monad m             => m a            -> ReaderT r m a
--   restoreT :: Monad m             => m (a, s)       -> StateT s m a
--   restoreT :: (Monad m, Monoid w) => m (a, w)       -> WriterT w m a
--   restoreT :: (Monad m, Monoid w) => m (a, s, w)    -> RWST r w s m a
--   
restoreT :: (MonadTransControl t, Monad m) => m (StT t a) -> t m a

-- | A function that runs a transformed monad t n on the monadic
--   state that was captured by liftWith
--   
--   A Run t function yields a computation in n that
--   returns the monadic state of t. This state can later be used
--   to restore a t computation using restoreT.
--   
--   Example type equalities:
--   
--   
--   Run IdentityT    ~ forall n b. Monad n             => IdentityT  n b -> n b
--   Run MaybeT       ~ forall n b. Monad n             => MaybeT     n b -> n (Maybe b)
--   Run (ErrorT e)   ~ forall n b. (Monad n, Error e)  => ErrorT e   n b -> n (Either e b)
--   Run (ExceptT e)  ~ forall n b. Monad n             => ExceptT e  n b -> n (Either e b)
--   Run ListT        ~ forall n b. Monad n             => ListT      n b -> n [b]
--   Run (ReaderT r)  ~ forall n b. Monad n             => ReaderT r  n b -> n b
--   Run (StateT s)   ~ forall n b. Monad n             => StateT s   n b -> n (a, s)
--   Run (WriterT w)  ~ forall n b. (Monad n, Monoid w) => WriterT w  n b -> n (a, w)
--   Run (RWST r w s) ~ forall n b. (Monad n, Monoid w) => RWST r w s n b -> n (a, s, w)
--   
--   
--   This type is usually satisfied by the run function of a
--   transformer:
--   
--   
--   flip runReaderT :: r -> Run (ReaderT r)
--   flip runStateT  :: s -> Run (StateT s)
--   runMaybeT       ::      Run MaybeT
--   
type Run (t :: Type -> Type -> Type -> Type) = forall (n :: Type -> Type) b. Monad n => t n b -> n StT t b

-- | A function like Run that runs a monad transformer t
--   which wraps the monad transformer t'. This is used in
--   defaultLiftWith.
type RunDefault (t :: Type -> Type -> Type -> Type) (t' :: Type -> Type -> Type -> Type) = forall (n :: Type -> Type) b. Monad n => t n b -> n StT t' b

-- | Default definition for the liftWith method.
defaultLiftWith :: (Monad m, MonadTransControl n) => (forall b. () => n m b -> t m b) -> (forall (o :: Type -> Type) b. () => t o b -> n o b) -> (RunDefault t n -> m a) -> t m a

-- | Default definition for the restoreT method.
defaultRestoreT :: (Monad m, MonadTransControl n) => (n m a -> t m a) -> m (StT n a) -> t m a

-- | A function like Run that runs a monad transformer t
--   which wraps the monad transformers n and n'. This is
--   used in defaultLiftWith2.
type RunDefault2 (t :: Type -> Type -> Type -> Type) (n :: Type -> Type -> Type -> Type) (n' :: Type -> Type -> Type -> Type) = forall (m :: Type -> Type) b. (Monad m, Monad n' m) => t m b -> m StT n' StT n b

-- | Default definition for the liftWith method.
defaultLiftWith2 :: forall m (n' :: (Type -> Type) -> Type -> Type) n t a. (Monad m, Monad (n' m), MonadTransControl n, MonadTransControl n') => (forall b. () => n (n' m) b -> t m b) -> (forall (o :: Type -> Type) b. () => t o b -> n (n' o) b) -> (RunDefault2 t n n' -> m a) -> t m a

-- | Default definition for the restoreT method for double
--   MonadTransControl.
defaultRestoreT2 :: forall m (n' :: (Type -> Type) -> Type -> Type) n a t. (Monad m, Monad (n' m), MonadTransControl n, MonadTransControl n') => (n (n' m) a -> t m a) -> m (StT n' (StT n a)) -> t m a

-- | 
Writing instances
--   
--   The usual way to write a MonadBaseControl instance for
--   a transformer stack over a base monad B is to write an
--   instance MonadBaseControl B B for the base monad, and
--   MonadTransControl T instances for every transformer
--   T. Instances for MonadBaseControl are then
--   simply implemented using ComposeSt,
--   defaultLiftBaseWith, defaultRestoreM.
class MonadBase b m => MonadBaseControl (b :: Type -> Type) (m :: Type -> Type) | m -> b where {
    
    -- | Monadic state that <tt>m</tt> adds to the base monad <tt>b</tt>.
    --   
    --   For all base (non-transformed) monads, <tt>StM m a ~ a</tt>:
    --   
    --   <pre>
    --   StM <a>IO</a>         a ~ a
    --   StM <a>Maybe</a>      a ~ a
    --   StM (<a>Either</a> e) a ~ a
    --   StM []         a ~ a
    --   StM ((-&gt;) r)   a ~ a
    --   StM <a>Identity</a>   a ~ a
    --   StM <a>STM</a>        a ~ a
    --   StM (<a>ST</a> s)     a ~ a
    --   </pre>
    --   
    --   If <tt>m</tt> is a transformed monad, <tt>m ~ t b</tt>,
    --   <tt><a>StM</a></tt> is the monadic state of the transformer <tt>t</tt>
    --   (given by its <a>StT</a> from <a>MonadTransControl</a>). For a
    --   transformer stack, <tt><a>StM</a></tt> is defined recursively:
    --   
    --   <pre>
    --   StM (<a>IdentityT</a>  m) a ~ <a>ComposeSt</a> <a>IdentityT</a> m a ~ StM m a
    --   StM (<a>MaybeT</a>     m) a ~ <a>ComposeSt</a> <a>MaybeT</a>    m a ~ StM m (<a>Maybe</a> a)
    --   StM (<tt>ErrorT</tt> e   m) a ~ <a>ComposeSt</a> <tt>ErrorT</tt>    m a ~ <tt>Error</tt> e =&gt; StM m (<a>Either</a> e a)
    --   StM (<a>ExceptT</a> e  m) a ~ <a>ComposeSt</a> <a>ExceptT</a>   m a ~ StM m (<a>Either</a> e a)
    --   StM (<tt>ListT</tt>      m) a ~ <a>ComposeSt</a> <tt>ListT</tt>     m a ~ StM m [a]
    --   StM (<a>ReaderT</a> r  m) a ~ <a>ComposeSt</a> <a>ReaderT</a>   m a ~ StM m a
    --   StM (<a>StateT</a> s   m) a ~ <a>ComposeSt</a> <a>StateT</a>    m a ~ StM m (a, s)
    --   StM (<a>WriterT</a> w  m) a ~ <a>ComposeSt</a> <a>WriterT</a>   m a ~ <a>Monoid</a> w =&gt; StM m (a, w)
    --   StM (<a>RWST</a> r w s m) a ~ <a>ComposeSt</a> <a>RWST</a>      m a ~ <a>Monoid</a> w =&gt; StM m (a, s, w)
    --   </pre>
    type StM (m :: Type -> Type) a;
}

-- | liftBaseWith is similar to liftIO and
--   liftBase in that it lifts a base computation to the
--   constructed monad.
--   
--   Instances should satisfy similar laws as the MonadIO and
--   MonadBase laws:
--   
--   
--   liftBaseWith (\_ -> return a) = return a
--   
--   
--   
--   liftBaseWith (\_ -> m >>= f)  =  liftBaseWith (\_ -> m) >>= (\a -> liftBaseWith (\_ -> f a))
--   
--   
--   As Li-yao Xia explains, parametricity guarantees that
--   
--   
--   f $ liftBaseWith q = liftBaseWith $ runInBase -> f $ q runInBase
--   
--   
--   The difference with liftBase is that before lifting the base
--   computation liftBaseWith captures the state of m. It
--   then provides the base computation with a RunInBase function
--   that allows running m computations in the base monad on the
--   captured state:
--   
--   
--   withFileLifted :: MonadBaseControl IO m => FilePath -> IOMode -> (Handle -> m a) -> m a
--   withFileLifted file mode action = liftBaseWith (\runInBase -> withFile file mode (runInBase . action)) >>= restoreM
--                                -- = control $ \runInBase -> withFile file mode (runInBase . action)
--                                -- = liftBaseOp (withFile file mode) action
--   
--   
--   liftBaseWith is usually not implemented directly, but
--   using defaultLiftBaseWith.
liftBaseWith :: MonadBaseControl b m => (RunInBase m b -> b a) -> m a

-- | Construct a m computation from the monadic state of
--   m that is returned from a RunInBase function.
--   
--   Instances should satisfy:
--   
--   
--   liftBaseWith (\runInBase -> runInBase m) >>= restoreM = m
--   
--   
--   restoreM is usually not implemented directly, but
--   using defaultRestoreM.
restoreM :: MonadBaseControl b m => StM m a -> m a

-- | A function that runs a m computation on the monadic state
--   that was captured by liftBaseWith
--   
--   A RunInBase m function yields a computation in the base monad
--   of m that returns the monadic state of m. This state
--   can later be used to restore the m computation using
--   restoreM.
--   
--   Example type equalities:
--   
--   
--   RunInBase (IdentityT  m) b ~ forall a.             IdentityT  m a -> b (StM m a)
--   RunInBase (MaybeT     m) b ~ forall a.             MaybeT     m a -> b (StM m (Maybe a))
--   RunInBase (ErrorT e   m) b ~ forall a. Error e =>  ErrorT e   m a -> b (StM m (Either e a))
--   RunInBase (ExceptT e  m) b ~ forall a.             ExceptT e  m a -> b (StM m (Either e a))
--   RunInBase (ListT      m) b ~ forall a.             ListT      m a -> b (StM m [a])
--   RunInBase (ReaderT r  m) b ~ forall a.             ReaderT    m a -> b (StM m a)
--   RunInBase (StateT s   m) b ~ forall a.             StateT s   m a -> b (StM m (a, s))
--   RunInBase (WriterT w  m) b ~ forall a. Monoid w => WriterT w  m a -> b (StM m (a, w))
--   RunInBase (RWST r w s m) b ~ forall a. Monoid w => RWST r w s m a -> b (StM m (a, s, w))
--   
--   
--   For a transformed base monad m ~ t b, 'RunInBase m b' ~
--   Run t.
type RunInBase (m :: Type -> Type) (b :: Type -> Type) = forall a. () => m a -> b StM m a

-- | Handy type synonym that composes the monadic states of t and
--   m.
--   
--   It can be used to define the StM for new
--   MonadBaseControl instances.
type ComposeSt (t :: Type -> Type -> Type -> Type) (m :: Type -> Type) a = StM m StT t a

-- | A function like RunInBase that runs a monad transformer
--   t in its base monad b. It is used in
--   defaultLiftBaseWith.
type RunInBaseDefault (t :: Type -> Type -> Type -> Type) (m :: Type -> Type) (b :: Type -> Type) = forall a. () => t m a -> b ComposeSt t m a

-- | Default definition for the liftBaseWith method.
--   
--   Note that it composes a liftWith of t with a
--   liftBaseWith of m to give a liftBaseWith of
--   t m:
--   
--   
--   defaultLiftBaseWith = \f -> liftWith $ \run ->
--                                 liftBaseWith $ \runInBase ->
--                                   f $ runInBase . run
--   
defaultLiftBaseWith :: forall t b (m :: Type -> Type) a. (MonadTransControl t, MonadBaseControl b m) => (RunInBaseDefault t m b -> b a) -> t m a

-- | Default definition for the restoreM method.
--   
--   Note that: defaultRestoreM = restoreT .
--   restoreM
defaultRestoreM :: forall t (b :: Type -> Type) (m :: Type -> Type) a. (MonadTransControl t, MonadBaseControl b m) => ComposeSt t m a -> t m a

-- | An often used composition: control f = liftBaseWith f
--   >>= restoreM
--   
--   Example:
--   
--   
--   liftedBracket :: MonadBaseControl IO m => m a -> (a -> m b) -> (a -> m c) -> m c
--   liftedBracket acquire release action = control $ \runInBase ->
--       bracket (runInBase acquire)
--               (\saved -> runInBase (restoreM saved >>= release))
--               (\saved -> runInBase (restoreM saved >>= action))
--   
control :: MonadBaseControl b m => (RunInBase m b -> b (StM m a)) -> m a

-- | Lift a computation and restore the monadic state immediately:
--   controlT f = liftWith f >>= restoreT .
--   return.
controlT :: (MonadTransControl t, Monad (t m), Monad m) => (Run t -> m (StT t a)) -> t m a

-- | Embed a transformer function as an function in the base monad
--   returning a mutated transformer state.
embed :: MonadBaseControl b m => (a -> m c) -> m (a -> b (StM m c))

-- | Performs the same function as embed, but discards transformer
--   state from the embedded function.
embed_ :: MonadBaseControl b m => (a -> m ()) -> m (a -> b ())

-- | Capture the current state of a transformer
captureT :: forall t (m :: Type -> Type). (MonadTransControl t, Monad (t m), Monad m) => t m (StT t ())

-- | Capture the current state above the base monad
captureM :: forall (b :: Type -> Type) m. MonadBaseControl b m => m (StM m ())

-- | liftBaseOp is a particular application of liftBaseWith
--   that allows lifting control operations of type:
--   
--   
--   ((a -> b c) -> b c)
--   
--   
--   to:
--   
--   
--   (MonadBaseControl b m => (a -> m c) -> m c)
--   
--   
--   For example:
--   
--   
--   liftBaseOp alloca :: (Storable a, MonadBaseControl IO m) => (Ptr a -> m c) -> m c
--   
liftBaseOp :: MonadBaseControl b m => ((a -> b (StM m c)) -> b (StM m d)) -> (a -> m c) -> m d

-- | liftBaseOp_ is a particular application of
--   liftBaseWith that allows lifting control operations of type:
--   
--   
--   (b a -> b a)
--   
--   
--   to:
--   
--   
--   (MonadBaseControl b m => m a -> m a)
--   
--   
--   For example:
--   
--   
--   liftBaseOp_ mask_ :: MonadBaseControl IO m => m a -> m a
--   
liftBaseOp_ :: MonadBaseControl b m => (b (StM m a) -> b (StM m c)) -> m a -> m c

-- | liftBaseDiscard is a particular application of
--   liftBaseWith that allows lifting control operations of type:
--   
--   
--   (b () -> b a)
--   
--   
--   to:
--   
--   
--   (MonadBaseControl b m => m () -> m a)
--   
--   
--   Note that, while the argument computation m () has access to
--   the captured state, all its side-effects in m are discarded.
--   It is run only for its side-effects in the base monad b.
--   
--   For example:
--   
--   
--   liftBaseDiscard forkIO :: MonadBaseControl IO m => m () -> m ThreadId
--   
liftBaseDiscard :: MonadBaseControl b m => (b () -> b a) -> m () -> m a

-- | liftBaseOpDiscard is a particular application of
--   liftBaseWith that allows lifting control operations of type:
--   
--   
--   ((a -> b ()) -> b c)
--   
--   
--   to:
--   
--   
--   (MonadBaseControl b m => (a -> m ()) -> m c)
--   
--   
--   Note that, while the argument computation m () has access to
--   the captured state, all its side-effects in m are discarded.
--   It is run only for its side-effects in the base monad b.
--   
--   For example:
--   
--   
--   liftBaseDiscard (runServer addr port) :: MonadBaseControl IO m => m () -> m ()
--   
liftBaseOpDiscard :: MonadBaseControl b m => ((a -> b ()) -> b c) -> (a -> m ()) -> m c

-- | Transform an action in t m using a transformer that operates
--   on the underlying monad m
liftThrough :: (MonadTransControl t, Monad (t m), Monad m) => (m (StT t a) -> m (StT t b)) -> t m a -> t m b
instance Control.Monad.Trans.Control.MonadBaseControl (GHC.Internal.Data.Either.Either e) (GHC.Internal.Data.Either.Either e)
instance Control.Monad.Trans.Control.MonadBaseControl ((->) r) ((->) r)
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO GHC.Types.IO
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Internal.Data.Functor.Identity.Identity GHC.Internal.Data.Functor.Identity.Identity
instance Control.Monad.Trans.Control.MonadBaseControl [] []
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Internal.Maybe.Maybe GHC.Internal.Maybe.Maybe
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Internal.Conc.Sync.STM GHC.Internal.Conc.Sync.STM
instance Control.Monad.Trans.Control.MonadBaseControl (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s) (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s)
instance Control.Monad.Trans.Control.MonadBaseControl (GHC.Internal.ST.ST s) (GHC.Internal.ST.ST s)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Internal.Base.Monoid w, Control.Monad.Trans.Control.MonadBaseControl b m) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Internal.Base.Monoid w, Control.Monad.Trans.Control.MonadBaseControl b m) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Internal.Base.Monoid w, Control.Monad.Trans.Control.MonadBaseControl b m) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Internal.Base.Monoid w, Control.Monad.Trans.Control.MonadBaseControl b m) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Except.ExceptT e)
instance Control.Monad.Trans.Control.MonadTransControl Control.Monad.Trans.Identity.IdentityT
instance Control.Monad.Trans.Control.MonadTransControl Control.Monad.Trans.Maybe.MaybeT
instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.RWS.Strict.RWST r w s)
instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.RWS.Lazy.RWST r w s)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Reader.ReaderT r)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.State.Strict.StateT s)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.State.Lazy.StateT s)
instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Writer.Strict.WriterT w)
instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Writer.Lazy.WriterT w)
