DeepControl.Monad.Reader

This module is just a concise mimic for Reader Monad in mtl(monad-transformer-library). The qualifier "concise" means that this module doesn't make no attempt to transform functions of any kind of Monad automatically. So when making some new data type of ReaderT, you have to manually define involved Monad instances, for example MonadError, by making use of the transformation functions such as trans, trans2, etc. Admittedly it is tedious though, you can deeply understand monad-transformation mechanism instead.

Documentation

class Monad m => MonadReader r m | m -> r where

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r

Retrieves the monad environment.

local

Arguments

:: (r -> r)

The function to modify the environment.

-> m a

Reader to run in the modified environment.

-> m a

Executes a computation in a modified environment.

reader

Arguments

:: (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

Instances

MonadReader r m => MonadReader r (MaybeT m)

MonadReader r m => MonadReader r (ListT m)

MonadReader r m => MonadReader r (IdentityT m)

MonadReader r ((->) r)

MonadReader r (Reader r)

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

MonadReader r m => MonadReader r (StateT s m)

MonadReader r m => MonadReader r (StateT s m)

Monad m => MonadReader r (ReaderT r m)

MonadReader r m => MonadReader r (ExceptT e m)

(Error e, MonadReader r m) => MonadReader r (ErrorT e m)

MonadReader r' m => MonadReader r' (ContT r m)

Monad m => MonadReader r (ReaderT r m)

Monoid w => MonadReader r (RWS r w s)

(Monad m1, Monad2 m2) => MonadReader r (ReaderT2 r m1 m2)

(Monoid w, Monad m) => MonadReader r (RWST r w s m)

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

(Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (ReaderT3 r m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2) => MonadReader r (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (RWST3 r w s m1 m2 m3)

asks :: MonadReader r m => (r -> a) -> m a

Level-0

newtype Reader r a

Constructors

Reader

Fields

runReader :: r -> a

Instances

MonadReader r (Reader r)

Monad (Reader r)

Functor (Reader r)

Applicative (Reader r)

Level-1

newtype ReaderT r m a

Constructors

ReaderT

Fields

runReaderT :: r -> m a

Instances

Monad m => MonadReader r (ReaderT r m)

MonadTrans (ReaderT r)

Monad m => Monad (ReaderT r m)

Functor m => Functor (ReaderT r m)

Monad m => Applicative (ReaderT s m)

(MonadIO m, Monad m) => MonadIO (ReaderT r m)

mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

liftCatch :: Catch e m a -> Catch e (ReaderT r m) a

Level-2

newtype ReaderT2 r m1 m2 a

Constructors

ReaderT2

Fields

runReaderT2 :: r -> m1 (m2 a)

Instances

(Monad m1, Monad2 m2) => MonadReader r (ReaderT2 r m1 m2)

MonadTrans2 (ReaderT2 r)

(Monad m1, Monad2 m2) => Monad (ReaderT2 r m1 m2)

(Functor m1, Functor m2) => Functor (ReaderT2 r m1 m2)

(Monad m1, Monad2 m2) => Applicative (ReaderT2 s m1 m2)

(MonadIO m1, Monad m1, Monad2 m2) => MonadIO (ReaderT2 r m1 m2)

mapReaderT2 :: (m1 (m2 a) -> n1 (n2 b)) -> ReaderT2 r m1 m2 a -> ReaderT2 r n1 n2 b

Level-3

newtype ReaderT3 r m1 m2 m3 a

Constructors

ReaderT3

Fields

runReaderT3 :: r -> m1 (m2 (m3 a))

Instances

(Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (ReaderT3 r m1 m2 m3)

MonadTrans3 (ReaderT3 r)

(Monad m1, Monad2 m2, Monad3 m3) => Monad (ReaderT3 r m1 m2 m3)

(Functor m1, Functor m2, Functor m3) => Functor (ReaderT3 r m1 m2 m3)

(Monad m1, Monad2 m2, Monad3 m3) => Applicative (ReaderT3 s m1 m2 m3)

(MonadIO m1, Monad m1, Monad2 m2, Monad3 m3) => MonadIO (ReaderT3 r m1 m2 m3)

mapReaderT3 :: (m1 (m2 (m3 a)) -> n1 (n2 (n3 b))) -> ReaderT3 r m1 m2 m3 a -> ReaderT3 r n1 n2 n3 b