module Control.Monad.Reader.Class (
MonadReader(..),
asks,
) where
import Control.Monad.Trans.Cont as Cont
import Control.Monad.Trans.Error
import Control.Monad.Trans.Except
import Control.Monad.Trans.Identity
import Control.Monad.Trans.List
import Control.Monad.Trans.Maybe
import Control.Monad.Trans.Reader (ReaderT)
import qualified Control.Monad.Trans.Reader as ReaderT (ask, local)
import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, ask, local)
import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (RWST, ask, local)
import Control.Monad.Trans.State.Lazy as Lazy
import Control.Monad.Trans.State.Strict as Strict
import Control.Monad.Trans.Writer.Lazy as Lazy
import Control.Monad.Trans.Writer.Strict as Strict
import Control.Monad.Trans
class (Monad m) => MonadReader m where
type EnvType m
ask :: m (EnvType m)
local :: (EnvType m -> EnvType m)
-> m a
-> m a
asks :: (MonadReader m)
=> (EnvType m -> a)
-> m a
asks :: forall (m :: * -> *) a. MonadReader m => (EnvType m -> a) -> m a
asks EnvType m -> a
f = do
EnvType m
r <- forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
forall (m :: * -> *) a. Monad m => a -> m a
return (EnvType m -> a
f EnvType m
r)
instance MonadReader ((->) r) where
type EnvType ((->) r) = r
ask :: r -> EnvType ((->) r)
ask = forall a. a -> a
id
local :: forall a.
(EnvType ((->) r) -> EnvType ((->) r)) -> (r -> a) -> r -> a
local EnvType ((->) r) -> EnvType ((->) r)
f r -> a
m = r -> a
m forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnvType ((->) r) -> EnvType ((->) r)
f
instance (Monad m) => MonadReader (ReaderT r m) where
type EnvType (ReaderT r m) = r
ask :: ReaderT r m (EnvType (ReaderT r m))
ask = forall (m :: * -> *) r. Monad m => ReaderT r m r
ReaderT.ask
local :: forall a.
(EnvType (ReaderT r m) -> EnvType (ReaderT r m))
-> ReaderT r m a -> ReaderT r m a
local = forall r (m :: * -> *) a.
(r -> r) -> ReaderT r m a -> ReaderT r m a
ReaderT.local
instance (Monoid w, Monad m) => MonadReader (LazyRWS.RWST r w s m) where
type EnvType (LazyRWS.RWST r w s m) = r
ask :: RWST r w s m (EnvType (RWST r w s m))
ask = forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m r
LazyRWS.ask
local :: forall a.
(EnvType (RWST r w s m) -> EnvType (RWST r w s m))
-> RWST r w s m a -> RWST r w s m a
local = forall r w s (m :: * -> *) a.
(r -> r) -> RWST r w s m a -> RWST r w s m a
LazyRWS.local
instance (Monoid w, Monad m) => MonadReader (StrictRWS.RWST r w s m) where
type EnvType (StrictRWS.RWST r w s m) = r
ask :: RWST r w s m (EnvType (RWST r w s m))
ask = forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m r
StrictRWS.ask
local :: forall a.
(EnvType (RWST r w s m) -> EnvType (RWST r w s m))
-> RWST r w s m a -> RWST r w s m a
local = forall r w s (m :: * -> *) a.
(r -> r) -> RWST r w s m a -> RWST r w s m a
StrictRWS.local
instance (MonadReader m) => MonadReader (ContT r m) where
type EnvType (ContT r m) = EnvType m
ask :: ContT r m (EnvType (ContT r m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (ContT r m) -> EnvType (ContT r m))
-> ContT r m a -> ContT r m a
local = forall (m :: * -> *) r' r a.
Monad m =>
m r'
-> ((r' -> r') -> m r -> m r)
-> (r' -> r')
-> ContT r m a
-> ContT r m a
Cont.liftLocal forall (m :: * -> *). MonadReader m => m (EnvType m)
ask forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (Error e, MonadReader m) => MonadReader (ErrorT e m) where
type EnvType (ErrorT e m) = EnvType m
ask :: ErrorT e m (EnvType (ErrorT e m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (ErrorT e m) -> EnvType (ErrorT e m))
-> ErrorT e m a -> ErrorT e m a
local = forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ErrorT e m a -> ErrorT e' n b
mapErrorT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (ExceptT e m) where
type EnvType (ExceptT e m) = EnvType m
ask :: ExceptT e m (EnvType (ExceptT e m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (ExceptT e m) -> EnvType (ExceptT e m))
-> ExceptT e m a -> ExceptT e m a
local = forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ExceptT e m a -> ExceptT e' n b
mapExceptT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (IdentityT m) where
type EnvType (IdentityT m) = EnvType m
ask :: IdentityT m (EnvType (IdentityT m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (IdentityT m) -> EnvType (IdentityT m))
-> IdentityT m a -> IdentityT m a
local = forall {k1} {k2} (m :: k1 -> *) (a :: k1) (n :: k2 -> *) (b :: k2).
(m a -> n b) -> IdentityT m a -> IdentityT n b
mapIdentityT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (ListT m) where
type EnvType (ListT m) = EnvType m
ask :: ListT m (EnvType (ListT m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (ListT m) -> EnvType (ListT m)) -> ListT m a -> ListT m a
local = forall (m :: * -> *) a (n :: * -> *) b.
(m [a] -> n [b]) -> ListT m a -> ListT n b
mapListT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (MaybeT m) where
type EnvType (MaybeT m) = EnvType m
ask :: MaybeT m (EnvType (MaybeT m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (MaybeT m) -> EnvType (MaybeT m))
-> MaybeT m a -> MaybeT m a
local = forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (Lazy.StateT s m) where
type EnvType (Lazy.StateT s m) = EnvType m
ask :: StateT s m (EnvType (StateT s m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (StateT s m) -> EnvType (StateT s m))
-> StateT s m a -> StateT s m a
local = forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Lazy.mapStateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (MonadReader m) => MonadReader (Strict.StateT s m) where
type EnvType (Strict.StateT s m) = EnvType m
ask :: StateT s m (EnvType (StateT s m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (StateT s m) -> EnvType (StateT s m))
-> StateT s m a -> StateT s m a
local = forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Strict.mapStateT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (Monoid w, MonadReader m) => MonadReader (Lazy.WriterT w m) where
type EnvType (Lazy.WriterT w m) = EnvType m
ask :: WriterT w m (EnvType (WriterT w m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (WriterT w m) -> EnvType (WriterT w m))
-> WriterT w m a -> WriterT w m a
local = forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Lazy.mapWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local
instance (Monoid w, MonadReader m) => MonadReader (Strict.WriterT w m) where
type EnvType (Strict.WriterT w m) = EnvType m
ask :: WriterT w m (EnvType (WriterT w m))
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). MonadReader m => m (EnvType m)
ask
local :: forall a.
(EnvType (WriterT w m) -> EnvType (WriterT w m))
-> WriterT w m a -> WriterT w m a
local = forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadReader m =>
(EnvType m -> EnvType m) -> m a -> m a
local