## Example

An example on how to compose the reader, writer, and state monad using monad transformers. The source code can be found in this repository

We want to implement a counter, that increments its value by a given constant.

We start by defining some types, and functions:

``````newtype Counter = MkCounter {cValue :: Int}
deriving (Show)

-- | 'inc c n' increments the counter by 'n' units.
inc :: Counter -> Int -> Counter
inc (MkCounter c) n = MkCounter (c + n)
``````

Assume we want to carry out the following computation using the counter:

• set the counter to 0
• set the increment constant to 3
• increment the counter 3 times
• set the increment constant to 5
• increment the counter 2 times

The state monad provides abstractions for passing state around. We can make use of the state monad, and define our increment function as a state transformer.

``````-- | CounterS is a monad.
type CounterS = State Counter

-- | Increment the counter by 'n' units.
incS :: Int-> CounterS ()
incS n = modify (\c -> inc c n)
``````

This already enables us to express a computation in a more clear and succinct way:

``````-- | The computation we want to run, with the state monad.
mComputationS :: CounterS ()
mComputationS = do
incS 3
incS 3
incS 3
incS 5
incS 5
``````

But we still have to pass the increment constant at each invocation. We would like to avoid this.

The reader monad provides a convenient way to pass an environment around. This monad is used in functional programming to perform what in the OO world is known as dependency injection.

• the type of the value being read (i.e. our environment, `r` below),

• the value returned by the reader monad (`a` below).

However, we need to make use of the state monad as well. Thus, we need to use the `ReaderT` transformer:

``````newtype ReaderT r m a :: * -> (* -> *) -> * -> *
``````

Using `ReaderT`, we can define our counter with environment and state as follows:

``````type CounterRS = ReaderT Int CounterS
``````

We define an `incR` function that takes the increment constant from the environment (using `ask`), and to define our increment function in terms of our `CounterS` monad we make use of the `lift` function (which belongs to the monad transformer class).

``````-- | Increment the counter by the amount of units specified by the environment.
incR :: CounterRS ()
incR = ask >>= lift . incS
``````

``````-- | The computation we want to run, using reader and state monads.
mComputationRS :: CounterRS ()
mComputationRS = do
local (const 3) \$ do
incR
incR
incR
local (const 5) \$ do
incR
incR
``````

## The requirements changed: we need logging!

Now assume that we want to add logging to our computation, so that we can see the evolution of our counter in time.

``````newtype WriterT w m a :: * -> (* -> *) -> * -> *
``````

Here `w` represents the type of the output to accumulate (which has to be a monoid, which allow us to accumulate this value), `m` is the inner monad, and `a` the type of the computation.

We can then define our counter with logging, environment, and state as follows:

``````type CounterWRS = WriterT [Int] CounterRS
``````

And making use of `lift` we can define the version of the increment function which logs the value of the counter after each increment:

``````incW :: CounterWRS ()
incW = lift incR >> get >>= tell . (:[]) . cValue
``````

Now the computation that contains logging can be written as follows:

``````mComputationWRS :: CounterWRS ()
mComputationWRS = do
local (const 3) \$ do
incW
incW
incW
local (const 5) \$ do
incW
incW
``````

## Doing everything in one go

This example intended to show monad transformers at work. However, we can achieve the same effect by composing all the aspects (environment, state, and logging) in a single increment operation.

To do this we make use of type-constraints:

``````inc' :: (MonadReader Int m, MonadState Counter m, MonadWriter [Int] m) => m ()
inc' = ask >>= modify . (flip inc) >> get >>= tell . (:[]) . cValue
``````

Here we arrive at a solution that will work for any monad that satisfies the constraints above. The computation function is defined thus with type:

``````mComputation' :: (MonadReader Int m, MonadState Counter m, MonadWriter [Int] m) => m ()
``````

since in its body we make use of inc'.

We could run this computation, in the `ghci` REPL for instance, as follows:

``````runState ( runReaderT ( runWriterT mComputation' ) 15 )  (MkCounter 0)
``````