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


-- | Reducing the pain of transformer stacks with duplicated effects
--   
--   The <tt>mtl</tt> provides a nice way to write monadic actions which
--   take advantage of a particular kind of effect (say, statefulness or
--   exception handling) without being forced to say exactly which monad is
--   providing that effect. However, if a transformer stack includes two
--   transformers that provide the given effect, <tt>mtl</tt> does not
--   provide a clean way to disambiguate which one is wanted; the topmost
--   one is always chosen.
--   
--   This package provides tools for disambiguating without being forced to
--   choose a particular transformer stack. It provides a separate stack
--   for each kind of effect; you may then disambiguate by depth within
--   each stack. For example, in a stack with two <tt>StateT</tt>
--   transformers, one can write
--   
--   <pre>
--   foo :: MonadStateDepth 0 m a =&gt; m a
--   foo = depthState @0 get
--   </pre>
--   
--   for access to the topmost state effects, or
--   
--   <pre>
--   bar :: MonadStateDepth 1 m a =&gt; m a
--   bar = depthState @1 get
--   </pre>
--   
--   for access to the state from underneath the topmost <tt>StateT</tt>,
--   no matter how deep in the stack the two <tt>StateT</tt>s are.
--   
--   See the readme for more detailed motivation, usage examples, and
--   documentation.
@package effect-stack
@version 0.3

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.Error
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.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Cont.ContT r m)
instance GHC.Base.Monad m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Maybe.MaybeT m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.RWS.CPS.RWST r w s m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Select.SelectT r m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Stack.Error.ErrorStack m => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.State.Strict.StateT s m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Writer.CPS.WriterT w m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.ErrorStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Control.Monad.Stack.Error.ErrorStack m, GHC.Base.Monoid w) => Control.Monad.Stack.Error.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)