    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeOperators #-}
    {-# LANGUAGE TypeSynonymInstances #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE UndecidableInstances #-}
    ----------------------------------------------------------------------
    -- |
    -- Module      :  Control.Monad.Representable.State
    -- Copyright   :  (c) Edward Kmett & Sjoerd Visscher 2011
    -- License     :  BSD3
    --
    -- Maintainer  :  ekmett@gmail.com
    -- Stability   :  experimental
    --
    -- A generalized State monad, parameterized by a Representable functor.
    -- The representation of that functor serves as the state.
    ----------------------------------------------------------------------
    module Control.Monad.Representable.State
       ( State
       , runState
       , evalState
       , execState
       , mapState
       , StateT(..)
       , stateT
       , runStateT
       , evalStateT
       , execStateT
       , mapStateT
       , liftCallCC
       , liftCallCC'
       , MonadState(..)
       ) where

    import Control.Monad
    import Data.Functor.Bind
    import Data.Functor.Bind.Trans
    import Control.Monad.State.Class
    import Control.Monad.Cont.Class (MonadCont(..))
    import Control.Monad.Reader.Class
    import Control.Monad.Writer.Class
    import Control.Monad.Free.Class
    import Control.Monad.Trans.Class
    import Data.Functor.Identity
    import Data.Functor.Rep

    -- ---------------------------------------------------------------------------
    -- | A memoized state monad parameterized by a representable functor @g@, where
    -- the representatation of @g@, @Rep g@ is the state to carry.
    --
    -- The 'return' function leaves the state unchanged, while @>>=@ uses
    -- the final state of the first computation as the initial state of
    -- the second.
    type State g = StateT g Identity

    -- | Unwrap a state monad computation as a function.
    -- (The inverse of 'state'.)
    runState :: Representable g
             => State g a   -- ^ state-passing computation to execute
             -> Rep g       -- ^ initial state
             -> (a, Rep g)  -- ^ return value and final state
    runState :: forall (g :: * -> *) a.
    Representable g =>
    State g a -> Rep g -> (a, Rep g)
    runState State g a
    m = Identity (a, Rep g) -> (a, Rep g)
    forall a. Identity a -> a
    runIdentity (Identity (a, Rep g) -> (a, Rep g))
    -> (Rep g -> Identity (a, Rep g)) -> Rep g -> (a, Rep g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . State g a -> Rep g -> Identity (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT State g a
    m

    -- | Evaluate a state computation with the given initial state
    -- and return the final value, discarding the final state.
    --
    -- * @'evalState' m s = 'fst' ('runState' m s)@
    evalState :: Representable g
              => State g a  -- ^state-passing computation to execute
              -> Rep g      -- ^initial value
              -> a          -- ^return value of the state computation
    evalState :: forall (g :: * -> *) a. Representable g => State g a -> Rep g -> a
    evalState State g a
    m Rep g
    s = (a, Rep g) -> a
    forall a b. (a, b) -> a
    fst (State g a -> Rep g -> (a, Rep g)
    forall (g :: * -> *) a.
    Representable g =>
    State g a -> Rep g -> (a, Rep g)
    runState State g a
    m Rep g
    s)

    -- | Evaluate a state computation with the given initial state
    -- and return the final state, discarding the final value.
    --
    -- * @'execState' m s = 'snd' ('runState' m s)@
    execState :: Representable g
              => State g a  -- ^state-passing computation to execute
              -> Rep g      -- ^initial value
              -> Rep g      -- ^final state
    execState :: forall (g :: * -> *) a.
    Representable g =>
    State g a -> Rep g -> Rep g
    execState State g a
    m Rep g
    s = (a, Rep g) -> Rep g
    forall a b. (a, b) -> b
    snd (State g a -> Rep g -> (a, Rep g)
    forall (g :: * -> *) a.
    Representable g =>
    State g a -> Rep g -> (a, Rep g)
    runState State g a
    m Rep g
    s)

    -- | Map both the return value and final state of a computation using
    -- the given function.
    --
    -- * @'runState' ('mapState' f m) = f . 'runState' m@
    mapState :: Functor g => ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b
    mapState :: forall (g :: * -> *) a b.
    Functor g =>
    ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b
    mapState (a, Rep g) -> (b, Rep g)
    f = (Identity (a, Rep g) -> Identity (b, Rep g))
    -> StateT g Identity a -> StateT g Identity b
    forall (g :: * -> *) (m :: * -> *) a (n :: * -> *) b.
    Functor g =>
    (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT ((b, Rep g) -> Identity (b, Rep g)
    forall a. a -> Identity a
    Identity ((b, Rep g) -> Identity (b, Rep g))
    -> (Identity (a, Rep g) -> (b, Rep g))
    -> Identity (a, Rep g)
    -> Identity (b, Rep g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a, Rep g) -> (b, Rep g)
    f ((a, Rep g) -> (b, Rep g))
    -> (Identity (a, Rep g) -> (a, Rep g))
    -> Identity (a, Rep g)
    -> (b, Rep g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Identity (a, Rep g) -> (a, Rep g)
    forall a. Identity a -> a
    runIdentity)

    -- ---------------------------------------------------------------------------
    -- | A state transformer monad parameterized by:
    --
    --   * @g@ - A representable functor used to memoize results for a state @Rep g@
    --
    --   * @m@ - The inner monad.
    --
    -- The 'return' function leaves the state unchanged, while @>>=@ uses
    -- the final state of the first computation as the initial state of
    -- the second.
    newtype StateT g m a = StateT { forall (g :: * -> *) (m :: * -> *) a.
    StateT g m a -> g (m (a, Rep g))
    getStateT :: g (m (a, Rep g)) }

    stateT :: Representable g => (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT :: forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT = g (m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (a, Rep g)) -> StateT g m a)
    -> ((Rep g -> m (a, Rep g)) -> g (m (a, Rep g)))
    -> (Rep g -> m (a, Rep g))
    -> StateT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Rep g -> m (a, Rep g)) -> g (m (a, Rep g))
    forall a. (Rep g -> a) -> g a
    forall (f :: * -> *) a. Representable f => (Rep f -> a) -> f a
    tabulate

    runStateT :: Representable g => StateT g m a -> Rep g -> m (a, Rep g)
    runStateT :: forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT (StateT g (m (a, Rep g))
    m) = g (m (a, Rep g)) -> Rep g -> m (a, Rep g)
    forall a. g a -> Rep g -> a
    forall (f :: * -> *) a. Representable f => f a -> Rep f -> a
    index g (m (a, Rep g))
    m

    mapStateT :: Functor g => (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT :: forall (g :: * -> *) (m :: * -> *) a (n :: * -> *) b.
    Functor g =>
    (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT m (a, Rep g) -> n (b, Rep g)
    f (StateT g (m (a, Rep g))
    m) = g (n (b, Rep g)) -> StateT g n b
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT ((m (a, Rep g) -> n (b, Rep g))
    -> g (m (a, Rep g)) -> g (n (b, Rep g))
    forall a b. (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap m (a, Rep g) -> n (b, Rep g)
    f g (m (a, Rep g))
    m)

    -- | Evaluate a state computation with the given initial state
    -- and return the final value, discarding the final state.
    --
    -- * @'evalStateT' m s = 'liftM' 'fst' ('runStateT' m s)@
    evalStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m a
    evalStateT :: forall (g :: * -> *) (m :: * -> *) a.
    (Representable g, Monad m) =>
    StateT g m a -> Rep g -> m a
    evalStateT StateT g m a
    m Rep g
    s = do
        (a, _) <- StateT g m a -> Rep g -> m (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT StateT g m a
    m Rep g
    s
        return a

    -- | Evaluate a state computation with the given initial state
    -- and return the final state, discarding the final value.
    --
    -- * @'execStateT' m s = 'liftM' 'snd' ('runStateT' m s)@
    execStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m (Rep g)
    execStateT :: forall (g :: * -> *) (m :: * -> *) a.
    (Representable g, Monad m) =>
    StateT g m a -> Rep g -> m (Rep g)
    execStateT StateT g m a
    m Rep g
    s = do
        (_, s') <- StateT g m a -> Rep g -> m (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT StateT g m a
    m Rep g
    s
        return s'

    instance (Functor g, Functor m) => Functor (StateT g m) where
      fmap :: forall a b. (a -> b) -> StateT g m a -> StateT g m b
    fmap a -> b
    f = g (m (b, Rep g)) -> StateT g m b
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (b, Rep g)) -> StateT g m b)
    -> (StateT g m a -> g (m (b, Rep g)))
    -> StateT g m a
    -> StateT g m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (m (a, Rep g) -> m (b, Rep g))
    -> g (m (a, Rep g)) -> g (m (b, Rep g))
    forall a b. (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (((a, Rep g) -> (b, Rep g)) -> m (a, Rep g) -> m (b, Rep g)
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ ~(a
    a, Rep g
    s) -> (a -> b
    f a
    a, Rep g
    s))) (g (m (a, Rep g)) -> g (m (b, Rep g)))
    -> (StateT g m a -> g (m (a, Rep g)))
    -> StateT g m a
    -> g (m (b, Rep g))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . StateT g m a -> g (m (a, Rep g))
    forall (g :: * -> *) (m :: * -> *) a.
    StateT g m a -> g (m (a, Rep g))
    getStateT

    instance (Representable g, Bind m) => Apply (StateT g m) where
      StateT g m (a -> b)
    mf <.> :: forall a b. StateT g m (a -> b) -> StateT g m a -> StateT g m b
    <.> StateT g m a
    ma = StateT g m (a -> b)
    mf StateT g m (a -> b) -> ((a -> b) -> StateT g m b) -> StateT g m b
    forall a b. StateT g m a -> (a -> StateT g m b) -> StateT g m b
    forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
    >>- \a -> b
    f -> (a -> b) -> StateT g m a -> StateT g m b
    forall a b. (a -> b) -> StateT g m a -> StateT g m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f StateT g m a
    ma

    instance (Representable g, Functor m, Monad m) => Applicative (StateT g m) where
      pure :: forall a. a -> StateT g m a
    pure = g (m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (a, Rep g)) -> StateT g m a)
    -> (a -> g (m (a, Rep g))) -> a -> StateT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, Rep g) -> m (a, Rep g)) -> a -> g (m (a, Rep g))
    forall (u :: * -> *) a b.
    Representable u =>
    ((a, Rep u) -> b) -> a -> u b
    leftAdjunctRep (a, Rep g) -> m (a, Rep g)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return
      StateT g m (a -> b)
    mf <*> :: forall a b. StateT g m (a -> b) -> StateT g m a -> StateT g m b
    <*> StateT g m a
    ma = StateT g m (a -> b)
    mf StateT g m (a -> b) -> ((a -> b) -> StateT g m b) -> StateT g m b
    forall a b. StateT g m a -> (a -> StateT g m b) -> StateT g m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a -> b
    f -> (a -> b) -> StateT g m a -> StateT g m b
    forall a b. (a -> b) -> StateT g m a -> StateT g m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f StateT g m a
    ma

    instance (Representable g, Bind m) => Bind (StateT g m) where
      StateT g (m (a, Rep g))
    m >>- :: forall a b. StateT g m a -> (a -> StateT g m b) -> StateT g m b
    >>- a -> StateT g m b
    f = g (m (b, Rep g)) -> StateT g m b
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (b, Rep g)) -> StateT g m b)
    -> g (m (b, Rep g)) -> StateT g m b
    forall a b. (a -> b) -> a -> b
    $ (m (a, Rep ((->) (Rep g))) -> m (b, Rep g))
    -> g (m (a, Rep ((->) (Rep g)))) -> g (m (b, Rep g))
    forall a b. (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (m (a, Rep ((->) (Rep g)))
    -> ((a, Rep ((->) (Rep g))) -> m (b, Rep g)) -> m (b, Rep g)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
    >>- (a -> Rep g -> m (b, Rep g))
    -> (a, Rep ((->) (Rep g))) -> m (b, Rep g)
    forall (u :: * -> *) a b.
    Representable u =>
    (a -> u b) -> (a, Rep u) -> b
    rightAdjunctRep (StateT g m b -> Rep g -> m (b, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT (StateT g m b -> Rep g -> m (b, Rep g))
    -> (a -> StateT g m b) -> a -> Rep g -> m (b, Rep g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> StateT g m b
    f)) g (m (a, Rep g))
    g (m (a, Rep ((->) (Rep g))))
    m

    instance (Representable g, Monad m) => Monad (StateT g m) where
      StateT g (m (a, Rep g))
    m >>= :: forall a b. StateT g m a -> (a -> StateT g m b) -> StateT g m b
    >>= a -> StateT g m b
    f = g (m (b, Rep g)) -> StateT g m b
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (b, Rep g)) -> StateT g m b)
    -> g (m (b, Rep g)) -> StateT g m b
    forall a b. (a -> b) -> a -> b
    $ (m (a, Rep ((->) (Rep g))) -> m (b, Rep g))
    -> g (m (a, Rep ((->) (Rep g)))) -> g (m (b, Rep g))
    forall a b. (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (m (a, Rep ((->) (Rep g)))
    -> ((a, Rep ((->) (Rep g))) -> m (b, Rep g)) -> m (b, Rep g)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (a -> Rep g -> m (b, Rep g))
    -> (a, Rep ((->) (Rep g))) -> m (b, Rep g)
    forall (u :: * -> *) a b.
    Representable u =>
    (a -> u b) -> (a, Rep u) -> b
    rightAdjunctRep (StateT g m b -> Rep g -> m (b, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT (StateT g m b -> Rep g -> m (b, Rep g))
    -> (a -> StateT g m b) -> a -> Rep g -> m (b, Rep g)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> StateT g m b
    f)) g (m (a, Rep g))
    g (m (a, Rep ((->) (Rep g))))
    m

    instance Representable f => BindTrans (StateT f) where
      liftB :: forall (b :: * -> *) a. Bind b => b a -> StateT f b a
    liftB b a
    m = (Rep f -> b (a, Rep f)) -> StateT f b a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep f -> b (a, Rep f)) -> StateT f b a)
    -> (Rep f -> b (a, Rep f)) -> StateT f b a
    forall a b. (a -> b) -> a -> b
    $ \Rep f
    s -> (a -> (a, Rep f)) -> b a -> b (a, Rep f)
    forall a b. (a -> b) -> b a -> b b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\a
    a -> (a
    a, Rep f
    s)) b a
    m

    instance Representable f => MonadTrans (StateT f) where
      lift :: forall (m :: * -> *) a. Monad m => m a -> StateT f m a
    lift m a
    m = (Rep f -> m (a, Rep f)) -> StateT f m a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep f -> m (a, Rep f)) -> StateT f m a)
    -> (Rep f -> m (a, Rep f)) -> StateT f m a
    forall a b. (a -> b) -> a -> b
    $ \Rep f
    s -> (a -> (a, Rep f)) -> m a -> m (a, Rep f)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\a
    a -> (a
    a, Rep f
    s)) m a
    m

    instance (Representable g, Monad m, Rep g ~ s) => MonadState s (StateT g m) where
      get :: StateT g m s
    get = (Rep g -> m (s, Rep g)) -> StateT g m s
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep g -> m (s, Rep g)) -> StateT g m s)
    -> (Rep g -> m (s, Rep g)) -> StateT g m s
    forall a b. (a -> b) -> a -> b
    $ \Rep g
    s -> (s, s) -> m (s, s)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (s
    Rep g
    s, s
    Rep g
    s)
      put :: s -> StateT g m ()
    put s
    s = g (m ((), Rep g)) -> StateT g m ()
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m ((), Rep g)) -> StateT g m ())
    -> g (m ((), Rep g)) -> StateT g m ()
    forall a b. (a -> b) -> a -> b
    $ m ((), Rep g) -> g (m ((), Rep g))
    forall (f :: * -> *) a. Representable f => a -> f a
    pureRep (m ((), Rep g) -> g (m ((), Rep g)))
    -> m ((), Rep g) -> g (m ((), Rep g))
    forall a b. (a -> b) -> a -> b
    $ ((), s) -> m ((), s)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((),s
    s)
      state :: forall a. (s -> (a, s)) -> StateT g m a
    state s -> (a, s)
    f = (Rep g -> m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((a, s) -> m (a, s)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((a, s) -> m (a, s)) -> (s -> (a, s)) -> s -> m (a, s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> (a, s)
    f)

    instance (Representable g, MonadReader e m) => MonadReader e (StateT g m) where
      ask :: StateT g m e
    ask = m e -> StateT g m e
    forall (m :: * -> *) a. Monad m => m a -> StateT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m e
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      local :: forall a. (e -> e) -> StateT g m a -> StateT g m a
    local = (m (a, Rep g) -> m (a, Rep g)) -> StateT g m a -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a (n :: * -> *) b.
    Functor g =>
    (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT ((m (a, Rep g) -> m (a, Rep g)) -> StateT g m a -> StateT g m a)
    -> ((e -> e) -> m (a, Rep g) -> m (a, Rep g))
    -> (e -> e)
    -> StateT g m a
    -> StateT g m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (e -> e) -> m (a, Rep g) -> m (a, Rep g)
    forall a. (e -> e) -> m a -> m a
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
    local

    instance (Representable g, MonadWriter w m) => MonadWriter w (StateT g m) where
      tell :: w -> StateT g m ()
    tell = m () -> StateT g m ()
    forall (m :: * -> *) a. Monad m => m a -> StateT g m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> StateT g m ()) -> (w -> m ()) -> w -> StateT g m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . w -> m ()
    forall w (m :: * -> *). MonadWriter w m => w -> m ()
    tell
      listen :: forall a. StateT g m a -> StateT g m (a, w)
    listen = (m (a, Rep g) -> m ((a, w), Rep g))
    -> StateT g m a -> StateT g m (a, w)
    forall (g :: * -> *) (m :: * -> *) a (n :: * -> *) b.
    Functor g =>
    (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT ((m (a, Rep g) -> m ((a, w), Rep g))
     -> StateT g m a -> StateT g m (a, w))
    -> (m (a, Rep g) -> m ((a, w), Rep g))
    -> StateT g m a
    -> StateT g m (a, w)
    forall a b. (a -> b) -> a -> b
    $ \m (a, Rep g)
    ma -> do
         ((a,s'), w) <- m (a, Rep g) -> m ((a, Rep g), w)
    forall a. m a -> m (a, w)
    forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
    listen m (a, Rep g)
    ma
         return ((a,w), s')
      pass :: forall a. StateT g m (a, w -> w) -> StateT g m a
    pass = (m ((a, w -> w), Rep g) -> m (a, Rep g))
    -> StateT g m (a, w -> w) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a (n :: * -> *) b.
    Functor g =>
    (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
    mapStateT ((m ((a, w -> w), Rep g) -> m (a, Rep g))
     -> StateT g m (a, w -> w) -> StateT g m a)
    -> (m ((a, w -> w), Rep g) -> m (a, Rep g))
    -> StateT g m (a, w -> w)
    -> StateT g m a
    forall a b. (a -> b) -> a -> b
    $ \m ((a, w -> w), Rep g)
    ma -> m ((a, Rep g), w -> w) -> m (a, Rep g)
    forall a. m (a, w -> w) -> m a
    forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
    pass (m ((a, Rep g), w -> w) -> m (a, Rep g))
    -> m ((a, Rep g), w -> w) -> m (a, Rep g)
    forall a b. (a -> b) -> a -> b
    $ do
        ((a, f), s') <- m ((a, w -> w), Rep g)
    ma
        return ((a, s'), f)

    instance (Representable g, MonadCont m) => MonadCont (StateT g m) where
        callCC :: forall a b. ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    callCC = ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    forall (g :: * -> *) a (m :: * -> *) b.
    Representable g =>
    ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    liftCallCC' (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    forall a b. ((a -> m b) -> m a) -> m a
    forall (m :: * -> *) a b. MonadCont m => ((a -> m b) -> m a) -> m a
    callCC

    instance (Functor f, Representable g, MonadFree f m) => MonadFree f (StateT g m) where
        wrap :: forall a. f (StateT g m a) -> StateT g m a
    wrap f (StateT g m a)
    as = (Rep g -> m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep g -> m (a, Rep g)) -> StateT g m a)
    -> (Rep g -> m (a, Rep g)) -> StateT g m a
    forall a b. (a -> b) -> a -> b
    $ \Rep g
    s -> f (m (a, Rep g)) -> m (a, Rep g)
    forall a. f (m a) -> m a
    forall (f :: * -> *) (m :: * -> *) a.
    MonadFree f m =>
    f (m a) -> m a
    wrap ((StateT g m a -> m (a, Rep g))
    -> f (StateT g m a) -> f (m (a, Rep g))
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (StateT g m a -> Rep g -> m (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    `runStateT` Rep g
    s) f (StateT g m a)
    as)

    leftAdjunctRep :: Representable u => ((a, Rep u) -> b) -> a -> u b
    leftAdjunctRep :: forall (u :: * -> *) a b.
    Representable u =>
    ((a, Rep u) -> b) -> a -> u b
    leftAdjunctRep (a, Rep u) -> b
    f a
    a = (Rep u -> b) -> u b
    forall a. (Rep u -> a) -> u a
    forall (f :: * -> *) a. Representable f => (Rep f -> a) -> f a
    tabulate (\Rep u
    s -> (a, Rep u) -> b
    f (a
    a,Rep u
    s))

    rightAdjunctRep :: Representable u => (a -> u b) -> (a, Rep u) -> b
    rightAdjunctRep :: forall (u :: * -> *) a b.
    Representable u =>
    (a -> u b) -> (a, Rep u) -> b
    rightAdjunctRep a -> u b
    f ~(a
    a, Rep u
    k) = a -> u b
    f a
    a u b -> Rep u -> b
    forall a. u a -> Rep u -> a
    forall (f :: * -> *) a. Representable f => f a -> Rep f -> a
    `index` Rep u
    k

    -- | Uniform lifting of a @callCC@ operation to the new monad.
    -- This version rolls back to the original state on entering the
    -- continuation.
    liftCallCC :: Representable g => ((((a,Rep g) -> m (b,Rep g)) -> m (a,Rep g)) -> m (a,Rep g)) ->
        ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    liftCallCC :: forall (g :: * -> *) a (m :: * -> *) b.
    Representable g =>
    ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    liftCallCC (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    callCC' (a -> StateT g m b) -> StateT g m a
    f = (Rep g -> m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep g -> m (a, Rep g)) -> StateT g m a)
    -> (Rep g -> m (a, Rep g)) -> StateT g m a
    forall a b. (a -> b) -> a -> b
    $ \Rep g
    s ->
        (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    callCC' ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    forall a b. (a -> b) -> a -> b
    $ \(a, Rep g) -> m (b, Rep g)
    c ->
        StateT g m a -> Rep g -> m (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT ((a -> StateT g m b) -> StateT g m a
    f (\a
    a -> g (m (b, Rep g)) -> StateT g m b
    forall (g :: * -> *) (m :: * -> *) a.
    g (m (a, Rep g)) -> StateT g m a
    StateT (g (m (b, Rep g)) -> StateT g m b)
    -> g (m (b, Rep g)) -> StateT g m b
    forall a b. (a -> b) -> a -> b
    $ m (b, Rep g) -> g (m (b, Rep g))
    forall (f :: * -> *) a. Representable f => a -> f a
    pureRep (m (b, Rep g) -> g (m (b, Rep g)))
    -> m (b, Rep g) -> g (m (b, Rep g))
    forall a b. (a -> b) -> a -> b
    $ (a, Rep g) -> m (b, Rep g)
    c (a
    a, Rep g
    s))) Rep g
    s

    -- | In-situ lifting of a @callCC@ operation to the new monad.
    -- This version uses the current state on entering the continuation.
    -- It does not satisfy the laws of a monad transformer.
    liftCallCC' :: Representable g => ((((a,Rep g) -> m (b,Rep g)) -> m (a,Rep g)) -> m (a,Rep g)) ->
        ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    liftCallCC' :: forall (g :: * -> *) a (m :: * -> *) b.
    Representable g =>
    ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
    liftCallCC' (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    callCC' (a -> StateT g m b) -> StateT g m a
    f = (Rep g -> m (a, Rep g)) -> StateT g m a
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep g -> m (a, Rep g)) -> StateT g m a)
    -> (Rep g -> m (a, Rep g)) -> StateT g m a
    forall a b. (a -> b) -> a -> b
    $ \Rep g
    s ->
        (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    callCC' ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g))
    -> (((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)
    forall a b. (a -> b) -> a -> b
    $ \(a, Rep g) -> m (b, Rep g)
    c ->
        StateT g m a -> Rep g -> m (a, Rep g)
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    StateT g m a -> Rep g -> m (a, Rep g)
    runStateT ((a -> StateT g m b) -> StateT g m a
    f (\a
    a -> (Rep g -> m (b, Rep g)) -> StateT g m b
    forall (g :: * -> *) (m :: * -> *) a.
    Representable g =>
    (Rep g -> m (a, Rep g)) -> StateT g m a
    stateT ((Rep g -> m (b, Rep g)) -> StateT g m b)
    -> (Rep g -> m (b, Rep g)) -> StateT g m b
    forall a b. (a -> b) -> a -> b
    $ \Rep g
    s' -> (a, Rep g) -> m (b, Rep g)
    c (a
    a, Rep g
    s'))) Rep g
    s