X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=zipper-lists-continuations.mdwn;h=142a2ba88d63ba3d4b31816c80af7c36a490284d;hp=6ec4d3418ac767f32b687d85c382db31d97f579f;hb=adfec786a8d1caa0ae42c1d392c76e99d305a975;hpb=d522d89b44b4ea898f8089ea2d2c7ec8384770de

diff --git a/zipper-lists-continuations.mdwn b/zipper-lists-continuations.mdwn
index 6ec4d341..142a2ba8 100644
--- a/zipper-lists-continuations.mdwn
+++ b/zipper-lists-continuations.mdwn
@@ -49,19 +49,24 @@ by applying it to an environment:
          .... f (u e) ...
 
 This subexpression types to `'b reader`, which is good.  The only
-problem is that we don't have an `e`, so we have to abstract over that
-variable:
+problem is that we invented an environment `e` that we didn't already have ,
+so we have to abstract over that variable to balance the books:
 
          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:
 
@@ -116,14 +121,14 @@ And sure enough,
 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