X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=from_lists_to_continuations.mdwn;h=be7e17f59c88d5797c2373ec5d9d435574221724;hp=f2e6989d14e362e2f9b10e2c5d5d07b08da49ae7;hb=7d27bb2510dd466a8c8135d83b3dc0150ce93bef;hpb=db72ac41480e82e56a4ac35fc2d710d610200486

diff --git a/from_lists_to_continuations.mdwn b/from_lists_to_continuations.mdwn
index f2e6989d..be7e17f5 100644
--- a/from_lists_to_continuations.mdwn
+++ b/from_lists_to_continuations.mdwn
@@ -6,7 +6,7 @@ to continuations is to re-functionalize a zipper.  Then the
 concreteness and understandability of the zipper provides a way of
 understanding and equivalent treatment using continuations.
 
-Let's work with lists of chars for a change.  To maximize readability, we'll
+Let's work with lists of `char`s for a change.  To maximize readability, we'll
 indulge in an abbreviatory convention that "abSd" abbreviates the
 list `['a'; 'b'; 'S'; 'd']`.
 
@@ -19,9 +19,7 @@ updated version.
 
 Expected behavior:
 
-<pre>
-t "abSd" ~~> "ababd"
-</pre>   
+	t "abSd" ~~> "ababd"
 
 
 In linguistic terms, this is a kind of anaphora
@@ -32,39 +30,33 @@ This deceptively simple task gives rise to some mind-bending complexity.
 Note that it matters which 'S' you target first (the position of the *
 indicates the targeted 'S'):
 
-<pre>
-    t "aSbS" 
-        *
-~~> t "aabS" 
-          *
-~~> "aabaab"
-</pre>
+	    t "aSbS" 
+	        *
+	~~> t "aabS" 
+	          *
+	~~> "aabaab"
 
 versus
 
-<pre>
-    t "aSbS"
-          *
-~~> t "aSbaSb" 
-        *
-~~> t "aabaSb"
-           *
-~~> "aabaaabab"
-</pre>   
+	    t "aSbS"
+	          *
+	~~> t "aSbaSb" 
+	        *
+	~~> t "aabaSb"
+	           *
+	~~> "aabaaabab"
 
 versus
 
-<pre>
-    t "aSbS"
-          *
-~~> t "aSbaSb"
-           *
-~~> t "aSbaaSbab"
-            *
-~~> t "aSbaaaSbaabab"
-             *
-~~> ...
-</pre>
+	    t "aSbS"
+	          *
+	~~> t "aSbaSb"
+	           *
+	~~> t "aSbaaSbab"
+	            *
+	~~> t "aSbaaaSbaabab"
+	             *
+	~~> ...
 
 Aparently, this task, as simple as it is, is a form of computation,
 and the order in which the `'S'`s get evaluated can lead to divergent
@@ -75,25 +67,23 @@ guarantees termination, and a final string without any `'S'` in it.
 
 This is a task well-suited to using a zipper.  We'll define a function
 `tz` (for task with zippers), which accomplishes the task by mapping a
-char list zipper to a char list.  We'll call the two parts of the
+`char list zipper` to a `char list`.  We'll call the two parts of the
 zipper `unzipped` and `zipped`; we start with a fully zipped list, and
-move elements to the zipped part by pulling the zipped down until the
+move elements to the zipped part by pulling the zipper down until the
 entire list has been unzipped (and so the zipped half of the zipper is empty).
 
-<pre>
-type 'a list_zipper = ('a list) * ('a list);;
-
-let rec tz (z:char list_zipper) = 
-    match z with (unzipped, []) -> List.rev(unzipped) (* Done! *)
-               | (unzipped, 'S'::zipped) -> tz ((List.append unzipped unzipped), zipped) 
-               | (unzipped, target::zipped) -> tz (target::unzipped, zipped);; (* Pull zipper *)
-
-# tz ([], ['a'; 'b'; 'S'; 'd']);;
-- : char list = ['a'; 'b'; 'a'; 'b'; 'd']
-
-# tz ([], ['a'; 'S'; 'b'; 'S']);;
-- : char list = ['a'; 'a'; 'b'; 'a'; 'a'; 'b']
-</pre>
+	type 'a list_zipper = ('a list) * ('a list);;
+	
+	let rec tz (z:char list_zipper) = 
+	    match z with (unzipped, []) -> List.rev(unzipped) (* Done! *)
+	               | (unzipped, 'S'::zipped) -> tz ((List.append unzipped unzipped), zipped) 
+	               | (unzipped, target::zipped) -> tz (target::unzipped, zipped);; (* Pull zipper *)
+	
+	# tz ([], ['a'; 'b'; 'S'; 'd']);;
+	- : char list = ['a'; 'b'; 'a'; 'b'; 'd']
+	
+	# tz ([], ['a'; 'S'; 'b'; 'S']);;
+	- : char list = ['a'; 'a'; 'b'; 'a'; 'a'; 'b']
 
 Note that this implementation enforces the evaluate-leftmost rule.
 Task completed.
@@ -131,8 +121,8 @@ to get there, we'll first do the exact same thing we just did with
 concrete zipper using procedures.  
 
 Think of a list as a procedural recipe: `['a'; 'b'; 'S'; 'd']` 
-is the result of the computation `a::(b::(S::(d::[])))` (or, in our old
-style, `makelist a (makelist b (makelist S (makelist c empty)))`).
+is the result of the computation `'a'::('b'::('S'::('d'::[])))` (or, in our old
+style, `make_list 'a' (make_list 'b' (make_list 'S' (make_list 'd' empty)))`).
 The recipe for constructing the list goes like this:
 
 <pre>
@@ -151,10 +141,10 @@ be a function of type `char list -> char list`.  We'll call each step
 context, a continuation is a function of type `char list -> char
 list`.  For instance, the continuation corresponding to the portion of
 the recipe below the horizontal line is the function `fun (tail:char
-list) -> a::(b::tail)`.
+list) -> 'a'::('b'::tail)`.
 
 This means that we can now represent the unzipped part of our
-zipper--the part we've already unzipped--as a continuation: a function
+zipper---the part we've already unzipped---as a continuation: a function
 describing how to finish building the list.  We'll write a new
 function, `tc` (for task with continuations), that will take an input
 list (not a zipper!) and a continuation and return a processed list.