4         There are systematic ways to layer different monads together. If you want to read about these, a keyword is "monad transformers." Ken Shan discusses them in [his paper](http://arxiv.org/abs/cs/0205026v1) that we recommended earlier.
6         However, since we haven't studied these, we will just combine the reader monad and the state monad in an ad hoc way. The easiest way to do this is to think of the assignment function and the store of reference cells as a combined state, which gets threaded through the computations in the same way that simple states did in your earlier homeworks.
8         We'll call these "discourse possibility monads," or `dpm`s, and type them as follows:
10                 type entity = Bob | Carol | Ted | Alice;;
11                 let domain = [Bob; Carol; Ted; Alice];;
12                 type assignment = char -> int;; (* variables are bound to indexes into the store *)
13                 type store = entity list;;
15                 type 'a dpm =
16                         (* we ignore worlds *)
17                         assignment * store -> 'a * assignment * store
19         Although we're leaving worlds out of the picture, each of these monadic values still represents a different *discourse* possibility: which entities might be being talked about, using which variables.
21         Since `dpm`s are to be a monad, we have to define a unit and a bind. These are just modeled on the unit and bind for the state monad:
23                 let unit_dpm (value : 'a) : 'a dpm = fun (r, h) -> (value, r, h);;
25                 let bind_dpm (u : 'a dpm) (f : 'a -> 'b dpm) : 'b dpm =
26                         fun (r, h) ->
27                                 let (a, r', h') = u (r, h)
28                                 in let u' = f a
29                                 in u' (r', h')
31 *       A *possibility* for GS&V is a triple of an assignment function `r`, a store `h`, and a world `w`. We're dropping worlds so we'll call pairs `(r, h)` *discourse possibilities*. *dpm*s are monads that represent computations that may mutate---or in GS&V's terminology "extend"---discourse possibilities. An `'a dpm` is a function that takes a starting `(r, h)` and returns an `'a` and a possibly mutated `r'` and `h'`.
33 *       Is that enough? If not, here are some [more hints](/hints/assignment_7_hint_3). But try to get as far as you can on your own.