X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=zipper-lists-continuations.mdwn;h=0ef943648f2d978ea838dfc81ed736c62db9ded2;hb=b9ab5e640cf6ead61cd72c4a484dd55d239a2bb5;hp=a14ed503a13a2f84b411616c985983115ff04160;hpb=9f7e25bd5aa94f5d0cdcd80a1ea0a48ff49a88fe;p=lambda.git

diff --git a/zipper-lists-continuations.mdwn b/zipper-lists-continuations.mdwn
index a14ed503..0ef94364 100644
--- a/zipper-lists-continuations.mdwn
+++ b/zipper-lists-continuations.mdwn
@@ -243,16 +243,9 @@ lists, so that they will print out.
 
 Ta da!
 
-Just for mnemonic purposes (sneaking in an instance of eta reduction
-to the definition of unit), we can summarize the result as follows:
-
-    type ('a, 'b) list' = ('a -> 'b -> 'b) -> 'b -> 'b
-    l'_unit x = fun f -> f x
-    l'_bind u f = fun k -> u (fun x -> f x k)
-
 To bad this digression, though it ties together various
 elements of the course, has *no relevance whatsoever* to the topic of
-continuations.
+continuations...
 
 Montague's PTQ treatment of DPs as generalized quantifiers
 ----------------------------------------------------------
@@ -278,10 +271,12 @@ the bind follow naturally.  We've done this enough times that we won't
 belabor the construction of the bind function, the derivation is
 similar to the List monad just given:
 
-   type 'a continuation = ('a -> 'b) -> 'b
-   c_unit (x:'a) = fun (p:'a -> 'b) -> p x
-   c_bind (u:('a -> 'b) -> 'b) (f: 'a -> ('c -> 'd) -> 'd): ('c -> 'd) -> 'd =
-     fun (k:'a -> 'b) -> u (fun (x:'a) -> f x k)
+<pre>
+type 'a continuation = ('a -> 'b) -> 'b
+c_unit (x:'a) = fun (p:'a -> 'b) -> p x
+c_bind (u:('a -> 'b) -> 'b) (f: 'a -> ('c -> 'd) -> 'd): ('c -> 'd) -> 'd =
+  fun (k:'a -> 'b) -> u (fun (x:'a) -> f x k)
+</pre>
 
 How similar is it to the List monad?  Let's examine the type
 constructor and the terms from the list monad derived above:
@@ -299,16 +294,15 @@ parallel in a deep sense.  To emphasize the parallel, we can
 instantiate the type of the list' monad using the Ocaml list type:
 
     type 'a c_list = ('a -> 'a list) -> 'a list
-    let c_list_unit x = fun f -> f x;;
-    let c_list_bind u f = fun k -> u (fun x -> f x k);;
 
-Have we really discovered that lists are secretly continuations?
-Or have we merely found a way of simulating lists using list
+Have we really discovered that lists are secretly continuations?  Or
+have we merely found a way of simulating lists using list
 continuations?  Both perspectives are valid, and we can use our
 intuitions about the list monad to understand continuations, and vice
-versa.  The connections will be expecially relevant when we consider 
-indefinites and Hamblin semantics on the linguistic side, and
-non-determinism on the list monad side.
+versa (not to mention our intuitions about primitive recursion in
+Church numerals too).  The connections will be expecially relevant
+when we consider indefinites and Hamblin semantics on the linguistic
+side, and non-determinism on the list monad side.
 
 Refunctionalizing zippers
 -------------------------