week11 tweaks

[lambda.git] / coroutines_and_aborts.mdwn

diff --git a/coroutines_and_aborts.mdwn b/coroutines_and_aborts.mdwn
index 50b6600..3822f41 100644 (file)
--- a/coroutines_and_aborts.mdwn
+++ b/coroutines_and_aborts.mdwn
@@ -10,10 +10,10 @@ Recall back in [[Assignment4]], we asked you to enumerate the "fringe" of a leaf
         / \                  / \
        1   2                2   3
 
-have the same fringe: `[1;2;3]`. We also asked you to write a function that determined when two trees have the same fringe. The way you approached that back then was to enumerate each tree's fringe, and then compare the two lists for equality. Today, and then again in a later class, we'll encounter new ways to approach the problem of determining when two trees have the same fringe.
+have the same fringe: `[1; 2; 3]`. We also asked you to write a function that determined when two trees have the same fringe. The way you approached that back then was to enumerate each tree's fringe, and then compare the two lists for equality. Today, and then again in a later class, we'll encounter new ways to approach the problem of determining when two trees have the same fringe.
 
 
-Supposing you did work out an implementation of the tree zipper, then one way to determine whether two trees have the same fringe would be: go downwards (and leftwards) in each tree as far as possible. Compare the targetted leaves. If they're different, stop because the trees have different fringes. If they're the same, then for each tree, move rightward if possible; if it's not (because you're at the rightmost position in a sibling list), more upwards then try again to move rightwards. Repeat until you are able to move rightwards. Once you do move rightwards, go downwards (and leftwards) as far as possible. Then you'll be targetted on the next leaf in the tree's fringe. The operations it takes to get to "the next leaf" may be different for the two trees. For example, in these trees:
+Supposing you did work out an implementation of the tree zipper, then one way to determine whether two trees have the same fringe would be: go downwards (and leftwards) in each tree as far as possible. Compare the targetted leaves. If they're different, stop because the trees have different fringes. If they're the same, then for each tree, move rightward if possible; if it's not (because you're at the rightmost position in a sibling list), move upwards then try again to move rightwards. Repeat until you are able to move rightwards. Once you do move rightwards, go downwards (and leftwards) as far as possible. Then you'll be targetted on the next leaf in the tree's fringe. The operations it takes to get to "the next leaf" may be different for the two trees. For example, in these trees:
 
            .                .
           / \              / \
@@ -47,7 +47,7 @@ and then having to remember which element in the triple was which:
 records let you attach descriptive labels to the components of the tuple:
 
        # type blah_record = { height : int; weight : int; char_tester : char -> bool };;
-       # let b2 = { height = 1; weight = 2; char_tester = fun c -> c = 'M' };;
+       # let b2 = { height = 1; weight = 2; char_tester = (fun c -> c = 'M') };;
        val b2 : blah_record = {height = 1; weight = 2; char_tester = <fun>}
        # let b3 = { height = 1; char_tester = (fun c -> c = 'K'); weight = 3 };; (* also works *)
        val b3 : blah_record = {height = 1; weight = 3; char_tester = <fun>}
@@ -70,7 +70,7 @@ Here is how you can extract the components of a labeled record:
 
        match test with
        | {height = h; weight = w; char_tester = test} ->
-         (* go on to use h, w, and test ... *)
+         (* same as preceding *)
 
 Anyway, using record types, we might define the tree zipper interface like so: