edits
[lambda.git] / assignment8.mdwn
index c954e95..0b53578 100644 (file)
@@ -8,15 +8,17 @@
 
                let rec move_botleft (z : 'a zipper) : 'a zipper =
                        (* returns z if the targetted node in z has no children *)
-                       (* else returns move_botleft (zipper which results from moving down and left in z) *)
-                       YOU SUPPLY THE DEFINITION
+                       (* else returns move_botleft (zipper which results from moving down from z to the leftmost child) *)
+                       _____
+                       (* YOU SUPPLY THE DEFINITION *)
 
 
                let rec move_right_or_up (z : 'a zipper) : 'a zipper option =
                        (* if it's possible to move right in z, returns Some (the result of doing so) *)
                        (* else if it's not possible to move any further up in z, returns None *)
                        (* else returns move_right_or_up (result of moving up in z) *)
-                       YOU SUPPLY THE DEFINITION
+                       _____
+                       (* YOU SUPPLY THE DEFINITION *)
 
 
                let new_zipper (t : 'a tree) : 'a zipper =
@@ -60,7 +62,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 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 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.
 
        This code uses Scheme's `cond` construct. That works like this;
 
                  (letrec ([helper (lambda (tree tailk)
                                  (cond
                                    [(pair? tree)
-                                     (helper (car tree) (lambda () (helper (cdr tree) tailk)))]
+                                     (helper (car tree) (lambda () (helper _____ tailk)))]
                                    [else (cons tree tailk)]))])
-                   (helper tree (lambda () (list)))))
+                   (helper tree (lambda () _____))))
                
                (define (stream-equal? stream1 stream2)
                  (cond
-                   [(and (null? stream1) (null? stream2)) #t]
+                   [(and (null? stream1) (null? stream2)) _____]
                    [(and (pair? stream1) (pair? stream2))
                     (and (equal? (car stream1) (car stream2))
-                         (stream-equal? ((cdr stream1)) ((cdr stream2))))]
+                         _____)]
                    [else #f]))
                
                (define (same-fringe? tree1 tree2)