added jsMath files
[lambda.git] / assignment8.mdwn
index a1e0140..f09556f 100644 (file)
@@ -1,10 +1,11 @@
-1.     Complete the definitions of `move_botleft` and `move_right_or_up` from the same-fringe solution in the [[week11]] notes. Test your attempts against some example trees to see if the resulting `make_fringe_enumerator` and `same_fringe` functions work as expected.
+1.     Complete the definitions of `move_botleft` and `move_right_or_up` from the same-fringe solution in the [[week11]] notes. **Test your attempts** against some example trees to see if the resulting `make_fringe_enumerator` and `same_fringe` functions work as expected. Show us some of your tests.
 
                type 'a tree = Leaf of 'a | Node of ('a tree * 'a tree)
 
-               type 'a starred_tree = Root | Starring_Left of 'a starred_pair | Starring_Right of 'a starred_pair
-               and 'a starred_pair = { parent : 'a starred_tree; sibling: 'a tree }
-               and 'a zipper = { tree : 'a starred_tree; filler: 'a tree };;
+               type 'a starred_level = Root | Starring_Left of 'a starred_nonroot | Starring_Right of 'a starred_nonroot
+               and 'a starred_nonroot = { parent : 'a starred_level; sibling: 'a tree };;
+
+               type 'a zipper = { level : 'a starred_level; filler: 'a tree };;
 
                let rec move_botleft (z : 'a zipper) : 'a zipper =
                        (* returns z if the targetted node in z has no children *)
 
 
                let new_zipper (t : 'a tree) : 'a zipper =
-                       {tree = Root; filler = t}
+                       {level = Root; filler = t}
                        ;;
 
         
 
                let make_fringe_enumerator (t: 'a tree) =
-                       (* create a zipper targetting the root of t *)
-                       let zstart = new_zipper t
-                       in let zbotleft = move_botleft zstart
+                       (* create a zipper targetting the botleft of t *)
+                       let zbotleft = move_botleft (new_zipper t)
                        (* create a refcell initially pointing to zbotleft *)
                        in let zcell = ref (Some zbotleft)
                        (* construct the next_leaf function *)
                        in let next_leaf () : 'a option =
                                match !zcell with
-                               | None -> (* we've finished enumerating the fringe *)
-                                       None
                                | Some z -> (
                                        (* extract label of currently-targetted leaf *)
                                        let Leaf current = z.filler
@@ -47,7 +45,9 @@
                                                | Some z' -> Some (move_botleft z')
                                        (* return saved label *)
                                        in Some current
-                               )
+                                   )
+                               | None -> (* we've finished enumerating the fringe *)
+                                       None
                        (* return the next_leaf function *)
                        in next_leaf
                        ;;
@@ -64,7 +64,7 @@
                        ;;
 
 
-2.     Here's another implementation of the same-fringe function, in Scheme. It's taken from <http://c2.com/cgi/wiki?SameFringeProblem>. It uses thunks to delay the evaluation of code that computes the tail of a list of a tree's fringe. It also involves passing continuations as arguments. Your assignment is to fill in the blanks in the code, and also to supply comments to the code, to explain what every significant piece is doing.
+2.     Here's another implementation of the same-fringe function, in Scheme. It's taken from <http://c2.com/cgi/wiki?SameFringeProblem>. It uses thunks to delay the evaluation of code that computes the tail of a list of a tree's fringe. It also involves passing "the rest of the enumeration of the fringe" as a thunk argument (`tail-thunk` below). Your assignment is to fill in the blanks in the code, **and also to supply comments to the code,** to explain what every significant piece is doing. Don't forget to supply the comments, this is an important part of the assignment.
 
        This code uses Scheme's `cond` construct. That works like this;
 
        Here is the implementation:
 
                (define (lazy-flatten tree)
-                 (letrec ([helper (lambda (tree tailk)
+                 (letrec ([helper (lambda (tree tail-thunk)
                                  (cond
                                    [(pair? tree)
-                                     (helper (car tree) (lambda () (helper _____ tailk)))]
-                                   [else (cons tree tailk)]))])
+                                     (helper (car tree) (lambda () (helper _____ tail-thunk)))]
+                                   [else (cons tree tail-thunk)]))])
                    (helper tree (lambda () _____))))
                
                (define (stream-equal? stream1 stream2)