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


-- | Reducing the pain of transformer stacks with duplicated effects
--   
--   When using monad transformer stacks, it is common to want to mix
--   effects from various layers of the stack within a single block of
--   code. The <tt>lift</tt> operation can be used to convert an action
--   that uses effects at some deep layer of the stack into one that works
--   in the full stack. It quickly becomes tedious to include exactly the
--   right number of calls to <tt>lift</tt> each time they are needed; and
--   makes the code more fragile when the transformer stack is changed
--   (e.g. to include a new effect).
--   
--   The <tt>mtl</tt> package provides a convenient way to point to a
--   particular layer of the stack, under the assumption that there is
--   exactly one "kind" of each interesting effect. (For example, one can
--   only have one type of state, one type of environment to read from, and
--   so forth.) However, if one wishes to have to copies of a single kind
--   of effect, there is no convenient, generic way to choose anything
--   other than the one that appears topmost in the stack. For example, for
--   a stack that contains two <tt>StateT</tt>s in it, one can write code
--   that accesses the outermost state using a type like
--   
--   <pre>
--   MonadState outer m =&gt; m ()
--   </pre>
--   
--   but there is no polymorphic way to reach the inner <tt>StateT</tt>'s
--   state. One is back to writing fragile code that depends on exactly
--   which transformer stack was chosen.
--   
--   This package provides a way to make such choices generically: it
--   introduces a separate stack for each kind of effect, and provides an
--   operation for popping one layer of a given effect's stack. Continuing
--   the <tt>StateT</tt> example, one could write
--   
--   <pre>
--   MonadState outer m =&gt; m ()
--   </pre>
--   
--   as before for the outermost state, or
--   
--   <pre>
--   (StateStack m, MonadState inner (PopState m)) =&gt; m ()
--   </pre>
--   
--   to access the state from underneath the outermost <tt>StateT</tt>, no
--   matter how deep it is. A sample action of that type would be
--   <tt>liftState get &gt;&gt; return ()</tt>. Equivalently, there is some
--   mild sugar that lets you write the type
--   
--   <pre>
--   MonadStateDepth 1 m inner =&gt; m ()
--   </pre>
--   
--   to mean the same thing as the previous type, and <tt>depthState @1 get
--   &gt;&gt; return ()</tt> to mean the same thing as the previous action.
@package effect-stack
@version 0.2.1

module Control.Monad.Stack.Internal

-- | ContT is polykinded, which leads to issues checking that ContT ~
--   ContT!
data ContTag
type family StackConstraints (n :: Nat) (c :: k) (cSucc :: k' -> Constraint) (m :: k') :: Constraint
type family IteratePop (n :: Nat) (c :: k) (m :: Type -> Type) :: Type -> Type
type family Pop (c :: k) (m :: k') :: k'
predNat :: forall n. KnownNat n => Either (n :~: 0) (Dict (KnownNat (n - 1)))
nonZeroNat :: forall n c cSucc m a. KnownNat (n - 1) => (IteratePop n c m a :~: IteratePop (n - 1) c (Pop c m) a, StackConstraints n c cSucc m :~: (cSucc m, StackConstraints (n - 1) c cSucc (Pop c m)))
depth :: forall n c cSucc m a. (KnownNat n, StackConstraints n c cSucc m) => (forall m. cSucc m => Pop c m a -> m a) -> IteratePop n c m a -> m a

module Control.Monad.Stack.Fail
class Monad m => FailStack m where {
    type family PopFail m :: * -> *;
}
liftFail :: FailStack m => PopFail m a -> m a
type FailDepth n m = IteratePop n MaybeT m
type FailConstraints n m = (KnownNat n, StackConstraints n MaybeT FailStack m)
type MonadFailDepth n m = (FailConstraints n m, MonadFail (FailDepth n m))
depthFail :: forall n m a. FailConstraints n m => FailDepth n m a -> m a
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Identity.IdentityT m)
instance GHC.Base.Monad m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Fail.FailStack m => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Fail.FailStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Fail.FailStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Except
class Monad m => ErrorStack m where {
    type family PopError m :: * -> *;
}
liftError :: ErrorStack m => PopError m a -> m a
type ErrorDepth n m = IteratePop n ExceptT m
type ErrorConstraints n m = (KnownNat n, StackConstraints n ExceptT ErrorStack m)
type MonadErrorDepth n m e = (ErrorConstraints n m, MonadError e (ErrorDepth n m))
depthError :: forall n m a. ErrorConstraints n m => ErrorDepth n m a -> m a
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Cont.ContT r m)
instance GHC.Base.Monad m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Except.ErrorStack m => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Except.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Except.ErrorStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Cont
class Monad m => ContStack m where {
    type family PopCont m :: * -> *;
}
liftCont :: ContStack m => PopCont m a -> m a
type ContDepth n m = IteratePop n ContTag m
type ContConstraints n m = (KnownNat n, StackConstraints n ContTag ContStack m)
type MonadContDepth n m = (ContConstraints n m, MonadCont (ContDepth n m))
depthCont :: forall n m a. ContConstraints n m => ContDepth n m a -> m a
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Accum.AccumT w m)
instance GHC.Base.Monad m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Cont.ContStack m => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Cont.ContStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Cont.ContStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Accum
class Monad m => AccumStack m where {
    type family PopAccum m :: * -> *;
}
liftAccum :: AccumStack m => PopAccum m a -> m a
type AccumDepth n m = IteratePop n AccumT m
type AccumConstraints n m = (KnownNat n, StackConstraints n AccumT AccumStack m)
depthAccum :: forall n m a. AccumConstraints n m => AccumDepth n m a -> m a
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Accum.AccumStack m => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Accum.AccumStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Accum.AccumStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Reader
class Monad m => ReaderStack m where {
    type family PopReader m :: * -> *;
}
liftReader :: ReaderStack m => PopReader m a -> m a
type ReaderDepth n m = IteratePop n ReaderT m
type ReaderConstraints n m = (KnownNat n, StackConstraints n ReaderT ReaderStack m)
type MonadReaderDepth n m r = (ReaderConstraints n m, MonadReader r (ReaderDepth n m))
depthReader :: forall n m a. ReaderConstraints n m => ReaderDepth n m a -> m a
instance (Control.Monad.Stack.Reader.ReaderStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Cont.ContT r m)
instance GHC.Base.Monad m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance GHC.Base.Monad m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Reader.ReaderStack m => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Reader.ReaderStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Reader.ReaderStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Reader.ReaderStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Reader.ReaderStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Select
class Monad m => SelectStack m where {
    type family PopSelect m :: * -> *;
}
liftSelect :: SelectStack m => PopSelect m a -> m a
type SelectDepth n m = IteratePop n SelectT m
type SelectConstraints n m = (KnownNat n, StackConstraints n SelectT SelectStack m)
depthSelect :: forall n m a. SelectConstraints n m => SelectDepth n m a -> m a
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Reader.ReaderT r m)
instance GHC.Base.Monad m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Select.SelectStack m => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Select.SelectStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Select.SelectStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.State
class Monad m => StateStack m where {
    type family PopState m :: * -> *;
}
liftState :: StateStack m => PopState m a -> m a
type StateDepth n m = IteratePop n StateT m
type StateConstraints n m = (KnownNat n, StackConstraints n StateT StateStack m)
type MonadStateDepth n m s = (StateConstraints n m, MonadState s (StateDepth n m))
depthState :: forall n m a. StateConstraints n m => StateDepth n m a -> m a
instance (Control.Monad.Stack.State.StateStack m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.State.StateStack m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Select.SelectT r m)
instance GHC.Base.Monad m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance GHC.Base.Monad m => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.State.StateStack m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.State.StateStack m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.State.StateStack m, GHC.Base.Monoid w) => Control.Monad.Stack.State.StateStack (Control.Monad.Trans.Writer.Strict.WriterT w m)

module Control.Monad.Stack.Writer
class Monad m => WriterStack m where {
    type family PopWriter m :: * -> *;
}
liftWriter :: WriterStack m => PopWriter m a -> m a
type WriterDepth n m = IteratePop n WriterT m
type WriterConstraints n m = (KnownNat n, StackConstraints n WriterT WriterStack m)
type MonadWriterDepth n m w = (WriterConstraints n m, MonadWriter w (WriterDepth n m))
depthWriter :: forall n m a. WriterConstraints n m => WriterDepth n m a -> m a
instance (Control.Monad.Stack.Writer.WriterStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Writer.WriterStack m => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Writer.WriterStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Writer.WriterStack (Control.Monad.Trans.Writer.Strict.WriterT w m)