fun e -> f (u e) ...
This types to `env -> 'b reader`, but we want to end up with `env ->
-'b`. The easiest way to turn a 'b reader into a 'b is to apply it to
+'b`. Once again, the easiest way to turn a `'b reader` into a `'b` is to apply it to
an environment. So we end up as follows:
r_bind (u:'a reader) (f:'a -> 'b reader):('b reader) = f (u e) e
And we're done.
+[This bind is a simplified version of the careful `let a = u e in ...`
+constructions we provided in earlier lectures. We use the simplified
+versions here in order to emphasize similarities of structure across
+monads; the official bind is still the one with the plethora of `let`'s.]
+
The **State Monad** is similar. We somehow intuit that we want to use
the following type constructor:
But where is the reasoning that led us to this unit and bind?
And what is the type `['a]`? Magic.
-So let's take a *completely useless digressing* and see if we can
-gain some insight into the details of the List monad. Let's choose
-type constructor that we can peer into, using some of the technology
-we built up so laboriously during the first half of the course. I'm
-going to use type 3 lists, partly because I know they'll give the
-result I want, but also because they're my favorite. These were the
-lists that made lists look like Church numerals with extra bits
-embdded in them:
+So let's indulge ourselves in a completely useless digression and see
+if we can gain some insight into the details of the List monad. Let's
+choose type constructor that we can peer into, using some of the
+technology we built up so laboriously during the first half of the
+course. I'm going to use type 3 lists, partly because I know they'll
+give the result I want, but also because they're my favorite. These
+were the lists that made lists look like Church numerals with extra
+bits embdded in them:
empty list: fun f z -> z
list with one element: fun f z -> f 1 z