{-# LANGUAGE Safe #-}{-# LANGUAGE FlexibleInstances #-}{-# LANGUAGE FunctionalDependencies #-}{-# LANGUAGE MultiParamTypeClasses #-}-- Search for UndecidableInstances to see why this is needed{-# LANGUAGE UndecidableInstances #-}-- Needed because the CPSed versions of Writer and State are secretly State-- wrappers, which don't force such constraints, even though they should legally-- be there.{-# OPTIONS_GHC -Wno-redundant-constraints #-}{- |
Module : Control.Monad.Reader.Class
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 : libraries@haskell.org
Stability : experimental
Portability : non-portable (multi-param classes, functional dependencies)
[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 'Control.Monad.State.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.
-}moduleControl.Monad.Reader.Class(MonadReader (..),asks ,)whereimportqualifiedControl.Monad.Trans.ContasContimportControl.Monad.Trans.Cont(ContT)importControl.Monad.Trans.Except(ExceptT,mapExceptT)importControl.Monad.Trans.Identity(IdentityT,mapIdentityT)importControl.Monad.Trans.Maybe(MaybeT,mapMaybeT)importControl.Monad.Trans.Reader(ReaderT)importqualifiedControl.Monad.Trans.ReaderasReaderTimportqualifiedControl.Monad.Trans.RWS.LazyasLazyRWSimportqualifiedControl.Monad.Trans.RWS.StrictasStrictRWSimportqualifiedControl.Monad.Trans.State.LazyasLazyimportqualifiedControl.Monad.Trans.State.StrictasStrictimportqualifiedControl.Monad.Trans.Writer.LazyasLazyimportqualifiedControl.Monad.Trans.Writer.StrictasStrictimportControl.Monad.Trans.Accum(AccumT)importqualifiedControl.Monad.Trans.AccumasAccumimportControl.Monad.Trans.Select(SelectT(SelectT),runSelectT)importqualifiedControl.Monad.Trans.RWS.CPSasCPSRWSimportqualifiedControl.Monad.Trans.Writer.CPSasCPSimportControl.Monad.Trans.Class(lift)-- ------------------------------------------------------------------------------ class MonadReader-- asks for the internal (non-mutable) state.-- | See examples in "Control.Monad.Reader".-- Note, the partially applied function type @(->) r@ is a simple reader monad.-- See the @instance@ declaration below.classMonadm =>MonadReader r m |m ->r where{-# MINIMAL(ask |reader ),local #-}-- | Retrieves the monad environment.ask ::m r ask =forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader forall a. a -> a
id-- | Executes a computation in a modified environment.local ::(r ->r )-- ^ The function to modify the environment.->m a -- ^ @Reader@ to run in the modified environment.->m a -- | Retrieves a function of the current environment.reader ::(r ->a )-- ^ The selector function to apply to the environment.->m a reader r -> a
f =dor
r <-forall r (m :: * -> *). MonadReader r m => m r
ask forall (m :: * -> *) a. Monad m => a -> m a
return(r -> a
f r
r )-- | Retrieves a function of the current environment.asks ::MonadReader r m =>(r ->a )-- ^ The selector function to apply to the environment.->m a asks :: forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks =forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader -- ------------------------------------------------------------------------------ The partially applied function type is a simple reader monadinstanceMonadReader r ((->)r )whereask :: r -> r
ask =forall a. a -> a
idlocal :: forall a. (r -> r) -> (r -> a) -> r -> a
local r -> r
f r -> a
m =r -> a
m forall b c a. (b -> c) -> (a -> b) -> a -> c
.r -> r
f reader :: forall a. (r -> a) -> r -> a
reader =forall a. a -> a
idinstanceMonadm =>MonadReader r (ReaderTr m )whereask :: ReaderT r m r
ask =forall (m :: * -> *) r. Monad m => ReaderT r m r
ReaderT.asklocal :: forall a. (r -> r) -> ReaderT r m a -> ReaderT r m a
local =forall r (m :: * -> *) a.
(r -> r) -> ReaderT r m a -> ReaderT r m a
ReaderT.localreader :: forall a. (r -> a) -> ReaderT r m a
reader =forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
ReaderT.reader-- | @since 2.3instance(Monadm ,Monoidw )=>MonadReader r (CPSRWS.RWSTr w s m )whereask :: RWST r w s m r
ask =forall (m :: * -> *) r w s. Monad m => RWST r w s m r
CPSRWS.asklocal :: forall a. (r -> r) -> 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
CPSRWS.localreader :: forall a. (r -> a) -> RWST r w s m a
reader =forall (m :: * -> *) r a w s. Monad m => (r -> a) -> RWST r w s m a
CPSRWS.readerinstance(Monadm ,Monoidw )=>MonadReader r (LazyRWS.RWSTr w s m )whereask :: RWST r w s m r
ask =forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m r
LazyRWS.asklocal :: forall a. (r -> r) -> 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.localreader :: forall a. (r -> a) -> RWST r w s m a
reader =forall w (m :: * -> *) r a s.
(Monoid w, Monad m) =>
(r -> a) -> RWST r w s m a
LazyRWS.readerinstance(Monadm ,Monoidw )=>MonadReader r (StrictRWS.RWSTr w s m )whereask :: RWST r w s m r
ask =forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m r
StrictRWS.asklocal :: forall a. (r -> r) -> 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.localreader :: forall a. (r -> a) -> RWST r w s m a
reader =forall w (m :: * -> *) r a s.
(Monoid w, Monad m) =>
(r -> a) -> RWST r w s m a
StrictRWS.reader-- ----------------------------------------------------------------------------- Instances for other mtl transformers---- All of these instances need UndecidableInstances,-- because they do not satisfy the coverage condition.instanceMonadReader r' m =>MonadReader r' (ContTr m )whereask :: ContT r m r'
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r' -> r') -> 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.liftLocalforall r (m :: * -> *). MonadReader r m => m r
ask forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r' -> a) -> ContT r m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader {- | @since 2.2 -}instanceMonadReader r m =>MonadReader r (ExceptTe m )whereask :: ExceptT e m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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
mapExceptTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> ExceptT e m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instanceMonadReader r m =>MonadReader r (IdentityTm )whereask :: IdentityT m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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
mapIdentityTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> IdentityT m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instanceMonadReader r m =>MonadReader r (MaybeTm )whereask :: MaybeT m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> MaybeT m a -> MaybeT m a
local =forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> MaybeT m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instanceMonadReader r m =>MonadReader r (Lazy.StateTs m )whereask :: StateT s m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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.mapStateTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> StateT s m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instanceMonadReader r m =>MonadReader r (Strict.StateTs m )whereask :: StateT s m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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.mapStateTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> StateT s m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader -- | @since 2.3instance(Monoidw ,MonadReader r m )=>MonadReader r (CPS.WriterTw m )whereask :: WriterT w m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> WriterT w m a -> WriterT w m a
local =forall (n :: * -> *) w w' (m :: * -> *) a b.
(Monad n, Monoid w, Monoid w') =>
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
CPS.mapWriterTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> WriterT w m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instance(Monoidw ,MonadReader r m )=>MonadReader r (Lazy.WriterTw m )whereask :: WriterT w m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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.mapWriterTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> WriterT w m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader instance(Monoidw ,MonadReader r m )=>MonadReader r (Strict.WriterTw m )whereask :: WriterT w m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> 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.mapWriterTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> WriterT w m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader -- | @since 2.3instance(Monoidw ,MonadReader r m )=>MonadReader r (AccumTw m )whereask :: AccumT w m r
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask local :: forall a. (r -> r) -> AccumT w m a -> AccumT w m a
local =forall (m :: * -> *) a w (n :: * -> *) b.
(m (a, w) -> n (b, w)) -> AccumT w m a -> AccumT w n b
Accum.mapAccumTforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local reader :: forall a. (r -> a) -> AccumT w m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader -- | @since 2.3instance(MonadReader r' m )=>MonadReader r' (SelectTr m )whereask :: SelectT r m r'
ask =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall r (m :: * -> *). MonadReader r m => m r
ask -- there is no Select.liftLocallocal :: forall a. (r' -> r') -> SelectT r m a -> SelectT r m a
local r' -> r'
f SelectT r m a
m =forall r (m :: * -> *) a. ((a -> m r) -> m a) -> SelectT r m a
SelectTforall a b. (a -> b) -> a -> b
$\a -> m r
c ->dor'
r <-forall r (m :: * -> *). MonadReader r m => m r
ask forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r' -> r'
f (forall r (m :: * -> *) a. SelectT r m a -> (a -> m r) -> m a
runSelectTSelectT r m a
m (forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (forall a b. a -> b -> a
constr'
r )forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> m r
c ))reader :: forall a. (r' -> a) -> SelectT r m a
reader =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader