Copyright | (c) Andy Gill 2001 (c) Oregon Graduate Institute of Science and Technology 2001 (c) Jeff Newbern 2003-2007 (c) Andriy Palamarchuk 2007 |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | ross@soi.city.ac.uk |
Stability | experimental |
Portability | non-portable (type families) |
Safe Haskell | None |
Language | GHC2021 |
Control.Monad.Reader
Description
- Computation type:
- Computations which read values from a shared environment.
- Binding strategy:
- Monad values are functions from the environment to a value. The bound function is applied to the bound value, and both have access to the shared environment.
- Useful for:
- Maintaining variable bindings, or other shared environment.
- Zero and plus:
- None.
- Example type:
Reader
[(String,Value)] a
The Reader
monad (also called the Environment monad).
Represents a computation, which can read values from
a shared environment, pass values from function to function,
and execute sub-computations in a modified environment.
Using Reader
monad for such computations is often clearer and easier
than using the State
monad.
Inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
Synopsis
- class Monad m => MonadReader (m :: Type -> Type) where
- asks :: MonadReader m => (EnvType m -> a) -> m a
- type Reader r = ReaderT r Identity
- runReader :: Reader r a -> r -> a
- mapReader :: (a -> b) -> Reader r a -> Reader r b
- withReader :: (r' -> r) -> Reader r a -> Reader r' a
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b
- withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- class Applicative m => Monad (m :: Type -> Type) where
- class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- class Functor (f :: Type -> Type) where
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- join :: Monad m => m (m a) -> m a
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- ap :: Monad m => m (a -> b) -> m a -> m b
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- when :: Applicative f => Bool -> f () -> f ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- void :: Functor f => f a -> f ()
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- unless :: Applicative f => Bool -> f () -> f ()
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- forever :: Applicative f => f a -> f b
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- guard :: Alternative f => Bool -> f ()
- class Monad m => MonadFix (m :: Type -> Type) where
- mfix :: (a -> m a) -> m a
- fix :: (a -> a) -> a
- module Control.Monad.Trans
MonadReader class
class Monad m => MonadReader (m :: Type -> Type) where Source #
See examples in Control.Monad.Reader.
Note, the partially applied function type (->) r
is a simple reader monad.
See the instance
declaration below.
Methods
Retrieves the monad environment.
Arguments
:: (EnvType m -> EnvType m) | The function to modify the environment. |
-> m a |
|
-> m a |
Executes a computation in a modified environment.
Instances
Arguments
:: MonadReader m | |
=> (EnvType m -> a) | The selector function to apply to the environment. |
-> m a |
Retrieves a function of the current environment.
The Reader monad
withReader :: (r' -> r) -> Reader r a -> Reader r' a #
The ReaderT monad transformer
newtype ReaderT r (m :: Type -> Type) a #
Constructors
ReaderT | |
Fields
|
Instances
Generic1 (ReaderT r m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Reader Associated Types
| |||||
MonadTrans (ReaderT r) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadFail m => MonadFail (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadFix m => MonadFix (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadIO m => MonadIO (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadZip m => MonadZip (ReaderT r m) | |||||
Contravariant m => Contravariant (ReaderT r m) | |||||
Alternative m => Alternative (ReaderT r m) | |||||
Applicative m => Applicative (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
Functor m => Functor (ReaderT r m) | |||||
Monad m => Monad (ReaderT r m) | |||||
MonadPlus m => MonadPlus (ReaderT r m) | |||||
MonadCont m => MonadCont (ReaderT r m) Source # | |||||
MonadError m => MonadError (ReaderT r m) Source # | |||||
Defined in Control.Monad.Except.Class Associated Types
| |||||
Monad m => MonadReader (ReaderT r m) Source # | |||||
Defined in Control.Monad.Reader.Class Associated Types
| |||||
MonadState m => MonadState (ReaderT r m) Source # | |||||
MonadWriter m => MonadWriter (ReaderT r m) Source # | |||||
Defined in Control.Monad.Writer.Class Associated Types
| |||||
Generic (ReaderT r m a) | |||||
Defined in Control.Monad.Trans.Reader Associated Types
| |||||
type Rep1 (ReaderT r m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Reader type Rep1 (ReaderT r m :: Type -> Type) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.0-a97a" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many r :: Type -> Type) :.: Rec1 m))) | |||||
type ErrorType (ReaderT r m) Source # | |||||
Defined in Control.Monad.Except.Class | |||||
type EnvType (ReaderT r m) Source # | |||||
Defined in Control.Monad.Reader.Class | |||||
type StateType (ReaderT r m) Source # | |||||
Defined in Control.Monad.State.Class | |||||
type WriterType (ReaderT r m) Source # | |||||
Defined in Control.Monad.Writer.Class | |||||
type Rep (ReaderT r m a) | |||||
Defined in Control.Monad.Trans.Reader type Rep (ReaderT r m a) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.0-a97a" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (r -> m a)))) |
mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b #
withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a #
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Down | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad NonEmpty | |
Monad STM | |
Monad NoIO | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad IO | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monad m => Monad (MaybeT m) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Rec1 f) | |
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (IdentityT m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (SelectT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
Monad m => Monad (Reverse m) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
Monad (ContT r m) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
Monad m => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadFail [] | |
Defined in Control.Monad.Fail | |
Monad m => MonadFail (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid | |
(Monoid w, MonadFail m) => MonadFail (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail m => MonadFail (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFail m => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
MonadFail m => MonadFail (Reverse m) | |
Defined in Data.Functor.Reverse | |
MonadFail m => MonadFail (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
MonadFail m => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Functor ZipList | |
Defined in Control.Applicative | |
Functor Handler | |
Defined in Control.Exception | |
Functor Complex | |
Defined in Data.Complex | |
Functor Identity | |
Functor First | |
Functor Last | |
Functor Down | |
Functor First | |
Defined in Data.Semigroup | |
Functor Last | |
Defined in Data.Semigroup | |
Functor Max | |
Defined in Data.Semigroup | |
Functor Min | |
Defined in Data.Semigroup | |
Functor Dual | |
Functor Product | |
Functor Sum | |
Functor NonEmpty | |
Functor STM | |
Defined in GHC.Conc.Sync | |
Functor NoIO | |
Functor Par1 | |
Defined in GHC.Generics | |
Functor ArgDescr | |
Defined in System.Console.GetOpt | |
Functor ArgOrder | |
Defined in System.Console.GetOpt | |
Functor OptDescr | |
Defined in System.Console.GetOpt | |
Functor P | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
Functor IO | |
Functor Maybe | |
Functor Solo | |
Functor [] | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
Arrow a => Functor (ArrowMonad a) | |
Defined in Control.Arrow | |
Functor (Either a) | |
Defined in Data.Either | |
Functor (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
Functor (Arg a) | |
Defined in Data.Semigroup | |
Functor (Array i) | |
Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (ST s) | |
Functor f => Functor (Lift f) | |
Defined in Control.Applicative.Lift | |
Functor m => Functor (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
Functor ((,) a) | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
Functor m => Functor (Kleisli m a) | |
Defined in Control.Arrow | |
Functor (Const m :: Type -> Type) | |
Defined in Data.Functor.Const | |
Functor f => Functor (Ap f) | |
Functor f => Functor (Alt f) | |
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Generics | |
Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Char :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Double :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Float :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Int :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Word :: Type -> Type) | |
Defined in GHC.Generics | |
Functor f => Functor (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Functor m => Functor (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
Functor m => Functor (ExceptT e m) | |
Functor m => Functor (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Functor m => Functor (ReaderT r m) | |
Functor m => Functor (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
Functor m => Functor (StateT s m) | |
Functor m => Functor (StateT s m) | |
Functor m => Functor (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
Functor m => Functor (WriterT w m) | |
Functor m => Functor (WriterT w m) | |
Functor (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Functor f => Functor (Reverse f) | |
Defined in Data.Functor.Reverse | |
Functor ((,,) a b) | |
(Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
(Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
(Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (ContT r m) | |
Functor ((,,,) a b c) | |
Functor ((->) r) | |
(Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
(Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
Functor m => Functor (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
Functor m => Functor (RWST r w s m) | |
Functor m => Functor (RWST r w s m) | |
Functor ((,,,,) a b c d) | |
Functor ((,,,,,) a b c d e) | |
Functor ((,,,,,,) a b c d e f) | |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
MonadPlus STM | |
Defined in GHC.Conc.Sync | |
MonadPlus P | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
MonadPlus IO | |
MonadPlus Maybe | |
MonadPlus [] | |
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | |
Defined in Control.Arrow | |
MonadPlus (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
MonadPlus (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Monad m => MonadPlus (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadPlus m => MonadPlus (Kleisli m a) | |
Defined in Control.Arrow | |
MonadPlus f => MonadPlus (Ap f) | |
MonadPlus f => MonadPlus (Alt f) | |
MonadPlus f => MonadPlus (Rec1 f) | |
Defined in GHC.Generics | |
(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
MonadPlus m => MonadPlus (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadPlus m => MonadPlus (ReaderT r m) | |
MonadPlus m => MonadPlus (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
MonadPlus m => MonadPlus (StateT s m) | |
MonadPlus m => MonadPlus (StateT s m) | |
(Functor m, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
MonadPlus m => MonadPlus (Reverse m) | |
Defined in Data.Functor.Reverse | |
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | |
Defined in Data.Functor.Product | |
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | |
Defined in GHC.Generics | |
MonadPlus f => MonadPlus (M1 i c f) | |
Defined in GHC.Generics | |
(Functor m, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
class Monad m => MonadFix (m :: Type -> Type) where #
Instances
MonadFix Complex | |
Defined in Data.Complex | |
MonadFix Identity | |
Defined in Data.Functor.Identity | |
MonadFix First | |
Defined in Control.Monad.Fix | |
MonadFix Last | |
Defined in Control.Monad.Fix | |
MonadFix Down | |
Defined in Control.Monad.Fix | |
MonadFix First | |
Defined in Data.Semigroup | |
MonadFix Last | |
Defined in Data.Semigroup | |
MonadFix Max | |
Defined in Data.Semigroup | |
MonadFix Min | |
Defined in Data.Semigroup | |
MonadFix Dual | |
Defined in Control.Monad.Fix | |
MonadFix Product | |
Defined in Control.Monad.Fix | |
MonadFix Sum | |
Defined in Control.Monad.Fix | |
MonadFix NonEmpty | |
Defined in Control.Monad.Fix | |
MonadFix Par1 | |
Defined in Control.Monad.Fix | |
MonadFix IO | |
Defined in Control.Monad.Fix | |
MonadFix Maybe | |
Defined in Control.Monad.Fix | |
MonadFix Solo | |
Defined in Control.Monad.Fix | |
MonadFix [] | |
Defined in Control.Monad.Fix | |
MonadFix (Either e) | |
Defined in Control.Monad.Fix | |
MonadFix (ST s) | |
Defined in Control.Monad.Fix | |
MonadFix m => MonadFix (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadFix f => MonadFix (Ap f) | |
Defined in Control.Monad.Fix | |
MonadFix f => MonadFix (Alt f) | |
Defined in Control.Monad.Fix | |
MonadFix f => MonadFix (Rec1 f) | |
Defined in Control.Monad.Fix | |
(Monoid w, Functor m, MonadFix m) => MonadFix (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
MonadFix m => MonadFix (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFix m => MonadFix (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadFix m => MonadFix (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFix m => MonadFix (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadFix m) => MonadFix (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, MonadFix m) => MonadFix (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(MonadFix f, MonadFix g) => MonadFix (Product f g) | |
Defined in Data.Functor.Product | |
(MonadFix f, MonadFix g) => MonadFix (f :*: g) | |
Defined in Control.Monad.Fix | |
MonadFix ((->) r) | |
Defined in Control.Monad.Fix | |
MonadFix f => MonadFix (M1 i c f) | |
Defined in Control.Monad.Fix | |
MonadFix m => MonadFix (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadFix m) => MonadFix (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, MonadFix m) => MonadFix (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
module Control.Monad.Trans
Example 1: Simple Reader Usage
In this example the Reader
monad provides access to variable bindings.
Bindings are a Map
of integer variables.
The variable count
contains number of variables in the bindings.
You can see how to run a Reader monad and retrieve data from it
with runReader
, how to access the Reader data with ask
and asks
.
type Bindings = Map String Int; -- Returns True if the "count" variable contains correct bindings size. isCountCorrect :: Bindings -> Bool isCountCorrect bindings = runReader calc_isCountCorrect bindings -- The Reader monad, which implements this complicated check. calc_isCountCorrect :: Reader Bindings Bool calc_isCountCorrect = do count <- asks (lookupVar "count") bindings <- ask return (count == (Map.size bindings)) -- The selector function to use with 'asks'. -- Returns value of the variable with specified name. lookupVar :: String -> Bindings -> Int lookupVar name bindings = fromJust (Map.lookup name bindings) sampleBindings = Map.fromList [("count",3), ("1",1), ("b",2)] main = do putStr $ "Count is correct for bindings " ++ (show sampleBindings) ++ ": "; putStrLn $ show (isCountCorrect sampleBindings);
Example 2: Modifying Reader Content With local
Shows how to modify Reader content with local
.
calculateContentLen :: Reader String Int calculateContentLen = do content <- ask return (length content); -- Calls calculateContentLen after adding a prefix to the Reader content. calculateModifiedContentLen :: Reader String Int calculateModifiedContentLen = local ("Prefix " ++) calculateContentLen main = do let s = "12345"; let modifiedLen = runReader calculateModifiedContentLen s let len = runReader calculateContentLen s putStrLn $ "Modified 's' length: " ++ (show modifiedLen) putStrLn $ "Original 's' length: " ++ (show len)
Example 3: ReaderT
Monad Transformer
Now you are thinking: 'Wow, what a great monad! I wish I could use
Reader functionality in MyFavoriteComplexMonad!'. Don't worry.
This can be easy done with the ReaderT
monad transformer.
This example shows how to combine ReaderT
with the IO monad.
-- The Reader/IO combined monad, where Reader stores a string. printReaderContent :: ReaderT String IO () printReaderContent = do content <- ask liftIO $ putStrLn ("The Reader Content: " ++ content) main = do runReaderT printReaderContent "Some Content"