
Control.Monad.Reader  Portability  nonportable (multiparam classes, functional dependencies)  Stability  experimental  Maintainer  libraries@haskell.org 





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 subcomputations 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
HigherOrder Polymorphism,
Mark P Jones (http://www.cse.ogi.edu/~mpj/)
Advanced School of Functional Programming, 1995.


Synopsis 



Documentation 

module Control.Monad.Reader.Class 

newtype Reader r a 
The parameterizable reader monad.
The return function creates a Reader that ignores the environment,
and produces the given value.
The binding operator >>= produces a Reader that uses the environment
to extract the value its lefthand side,
and then applies the bound function to that value in the same environment.
 Constructors  Reader   runReader :: (r > a)  Runs Reader and extracts the final value from it.
To extract the value apply (runReader reader) to an environment value.
Parameters:
 A Reader to run.
 An initial environment.


 Instances  


mapReader :: (a > b) > Reader r a > Reader r b 

withReader :: (r' > r) > Reader r a > Reader r' a 
A more general version of local.


newtype ReaderT r m a 
The reader monad transformer.
Can be used to add environment reading functionality to other monads.
 Constructors   Instances  


mapReaderT :: (m a > n b) > ReaderT w m a > ReaderT w n b 

withReaderT :: (r' > r) > ReaderT r m a > ReaderT r' m a 

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"


Produced by Haddock version 0.7 