X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=assignment9.mdwn;h=13cf8fd4a89c9165cc201589cfa402312d7f71d7;hp=f476ab736005b5f1b3bf7b7b0fb7858062733807;hb=d0c1b524d79cd88b2979d7825dc297bbbddc4f22;hpb=965ee4cd27ebb4caa5ace62806e992bd2db20266

diff --git a/assignment9.mdwn b/assignment9.mdwn
index f476ab73..13cf8fd4 100644
--- a/assignment9.mdwn
+++ b/assignment9.mdwn
@@ -62,7 +62,7 @@ Two strategies for solving the problem
     does: compute the tree-to-list transformation for a tree with two
     leaves, performing all beta reduction by hand using the
     definitions for bind\_continuation, unit\_continuation and so on.
-    If you take this route, study the description of streams (a
+    If you take this route, study the description of **streams** (a
     particular kind of data structure) below.  The goal will be to
     arrange for the continuation-flavored tree_monadizer to transform
     a tree into a stream instead of into a list.  Once you've done
@@ -104,9 +104,9 @@ class notes for [[week6]] on thunks, as well as [[assignment5]]).
 
 There is a special stream called `End` that represents a stream that
 contains no (more) elements, analogous to the empty list `[]`.
-Streams that are not empty contain a first object paired with a
+Streams that are not empty contain a first object, paired with a
 thunked stream representing the rest of the series.  In order to get
-access to the next element in the stream, we must forced the thunk by
+access to the next element in the stream, we must *force* the thunk by
 applying it to the unit.  Watch the behavior of this stream in detail.
 This stream delivers the natural numbers, in order: 1, 2, 3, ...
 
@@ -118,14 +118,14 @@ val make_int_stream : int -> int stream = [fun]
 val int_stream : int stream = Next (1, [fun])         (* First element: 1 *)
 
 # let tail = match int_stream with Next (i, rest) -> rest;;      
-val tail : unit -> int stream = <fun>                 (* Tail: a thunk *)
+val tail : unit -> int stream = [fun]                 (* Tail: a thunk *)
 
 (* Force the thunk to compute the second element *)
 # tail ();;
-- : int stream = Next (2, [fun])      
+- : int stream = Next (2, [fun])                      (* Second element: 2 *)
 
 # match tail () with Next (_, rest) -> rest ();;
-- : int stream = Next (3, <fun>)
+- : int stream = Next (3, [fun])                      (* Third element: 3 *)
 </pre>
 
 You can think of `int_stream` as a functional object that provides