module Control.Monad.Ology.Specific.ReaderStateT where

import Control.Monad.Ology.Data
import Control.Monad.Ology.General
import Control.Monad.Ology.Specific.StateT
import Import

type ReaderStateT f m = StateT (WRaised f m) m

evalReaderStateT :: Monad m => ReaderStateT f m a -> (f --> m) -> m a
evalReaderStateT :: forall (m :: Type -> Type) (f :: Type -> Type) a.
Monad m =>
ReaderStateT f m a -> (f --> m) -> m a
evalReaderStateT ReaderStateT f m a
rsa f --> m
fm = ReaderStateT f m a -> WRaised f m -> m a
forall (m :: Type -> Type) s a. Monad m => StateT s m a -> s -> m a
evalStateT ReaderStateT f m a
rsa ((f --> m) -> WRaised f m
forall k (p :: k -> Type) (q :: k -> Type).
(p --> q) -> WRaised p q
MkWRaised f a -> m a
f --> m
fm)

readerStateLift :: (Monad f, Monad m) => f --> ReaderStateT f m
readerStateLift :: forall (f :: Type -> Type) (m :: Type -> Type).
(Monad f, Monad m) =>
f --> ReaderStateT f m
readerStateLift f a
fa = do
    MkWRaised f --> m
fm <- StateT (WRaised f m) m (WRaised f m)
forall (m :: Type -> Type) s. Monad m => StateT s m s
get
    a
a <- m a -> ReaderStateT f m a
forall (m :: Type -> Type) a.
Monad m =>
m a -> StateT (WRaised f m) m a
forall (t :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderStateT f m a) -> m a -> ReaderStateT f m a
forall a b. (a -> b) -> a -> b
$ f a -> m a
f --> m
fm f a
fa
    WRaised f m -> StateT (WRaised f m) m ()
forall (m :: Type -> Type) s. Monad m => s -> StateT s m ()
put (WRaised f m -> StateT (WRaised f m) m ())
-> WRaised f m -> StateT (WRaised f m) m ()
forall a b. (a -> b) -> a -> b
$ (f --> m) -> WRaised f m
forall k (p :: k -> Type) (q :: k -> Type).
(p --> q) -> WRaised p q
MkWRaised ((f --> m) -> WRaised f m) -> (f --> m) -> WRaised f m
forall a b. (a -> b) -> a -> b
$ \f a
c -> f a -> m a
f --> m
fm (f a -> m a) -> f a -> m a
forall a b. (a -> b) -> a -> b
$ f a
fa f a -> f a -> f a
forall a b. f a -> f b -> f b
forall (m :: Type -> Type) a b. Monad m => m a -> m b -> m b
>> f a
c
    a -> ReaderStateT f m a
forall a. a -> StateT (WRaised f m) m a
forall (m :: Type -> Type) a. Monad m => a -> m a
return a
a

readerStateUpdate :: Monad m => (f --> f) -> ReaderStateT f m ()
readerStateUpdate :: forall (m :: Type -> Type) (f :: Type -> Type).
Monad m =>
(f --> f) -> ReaderStateT f m ()
readerStateUpdate f --> f
ff = (WRaised f m -> WRaised f m) -> StateT (WRaised f m) m ()
forall (m :: Type -> Type) s. Monad m => (s -> s) -> StateT s m ()
modify (\WRaised f m
fm -> WRaised f m
fm WRaised f m -> WRaised f f -> WRaised f m
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
forall (b :: Type -> Type) (c :: Type -> Type) (a :: Type -> Type).
WRaised b c -> WRaised a b -> WRaised a c
. (f --> f) -> WRaised f f
forall k (p :: k -> Type) (q :: k -> Type).
(p --> q) -> WRaised p q
MkWRaised f a -> f a
f --> f
ff)

readerStateParamRef ::
       forall f m. Monad m
    => Param f --> Ref (ReaderStateT f m)
readerStateParamRef :: forall (f :: Type -> Type) (m :: Type -> Type).
Monad m =>
Param f --> Ref (ReaderStateT f m)
readerStateParamRef (Param f a
param :: _ a) = let
    refGet :: ReaderStateT f m a
    refGet :: StateT (WRaised f m) m a
refGet = do
        MkWRaised f --> m
ff <- StateT (WRaised f m) m (WRaised f m)
forall (m :: Type -> Type) s. Monad m => StateT s m s
get
        m a -> StateT (WRaised f m) m a
forall (m :: Type -> Type) a.
Monad m =>
m a -> StateT (WRaised f m) m a
forall (t :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT (WRaised f m) m a)
-> m a -> StateT (WRaised f m) m a
forall a b. (a -> b) -> a -> b
$ f a -> m a
f --> m
ff (f a -> m a) -> f a -> m a
forall a b. (a -> b) -> a -> b
$ Param f a -> f a
forall (m :: Type -> Type) a. Param m a -> m a
paramAsk Param f a
param
    refPut :: a -> ReaderStateT f m ()
    refPut :: a -> StateT (WRaised f m) m ()
refPut a
a = (f --> f) -> StateT (WRaised f m) m ()
forall (m :: Type -> Type) (f :: Type -> Type).
Monad m =>
(f --> f) -> ReaderStateT f m ()
readerStateUpdate ((f --> f) -> StateT (WRaised f m) m ())
-> (f --> f) -> StateT (WRaised f m) m ()
forall a b. (a -> b) -> a -> b
$ Param f a -> a -> f --> f
forall (m :: Type -> Type) a. Param m a -> a -> m --> m
paramWith Param f a
param a
a
    in MkRef {StateT (WRaised f m) m a
a -> StateT (WRaised f m) m ()
refGet :: StateT (WRaised f m) m a
refPut :: a -> StateT (WRaised f m) m ()
refPut :: a -> StateT (WRaised f m) m ()
refGet :: StateT (WRaised f m) m a
..}