1 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.
3 type 'a tree = Leaf of 'a | Node of ('a tree * 'a tree)
5 type 'a starred_tree = Root | Starring_Left of 'a starred_pair | Starring_Right of 'a starred_pair
6 and 'a starred_pair = { parent : 'a starred_tree; sibling: 'a tree }
7 and 'a zipper = { tree : 'a starred_tree; filler: 'a tree };;
9 let rec move_botleft (z : 'a zipper) : 'a zipper =
10 (* returns z if the targetted node in z has no children *)
11 (* else returns move_botleft (zipper which results from moving down and left in z) *)
12 YOU SUPPLY THE DEFINITION
15 let rec move_right_or_up (z : 'a zipper) : 'a zipper option =
16 (* if it's possible to move right in z, returns Some (the result of doing so) *)
17 (* else if it's not possible to move any further up in z, returns None *)
18 (* else returns move_right_or_up (result of moving up in z) *)
19 YOU SUPPLY THE DEFINITION
22 let new_zipper (t : 'a tree) : 'a zipper =
23 {tree = Root; filler = t}
26 let make_fringe_enumerator (t: 'a tree) =
27 (* create a zipper targetting the root of t *)
28 let zstart = new_zipper t
29 in let zbotleft = move_botleft zstart
30 (* create a refcell initially pointing to zbotleft *)
31 in let zcell = ref (Some zbotleft)
32 (* construct the next_leaf function *)
33 in let next_leaf () : 'a option =
35 | None -> (* we've finished enumerating the fringe *)
38 (* extract label of currently-targetted leaf *)
39 let Leaf current = z.filler
40 (* update zcell to point to next leaf, if there is one *)
41 in let () = zcell := match move_right_or_up z with
43 | Some z' -> Some (move_botleft z')
44 (* return saved label *)
47 (* return the next_leaf function *)
51 let same_fringe (t1 : 'a tree) (t2 : 'a tree) : bool =
52 let next1 = make_fringe_enumerator t1
53 in let next2 = make_fringe_enumerator t2
54 in let rec loop () : bool =
55 match next1 (), next2 () with
56 | Some a, Some b when a = b -> loop ()
63 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.
65 This code uses Scheme's `cond` construct. That works like this;
68 ((test1 argument argument) result1)
69 ((test2 argument argument) result2)
70 ((test3 argument argument) result3)
75 (if (test1 argument argument)
77 (if (test2 argument argument)
79 (if (test3 argument argument)
83 Some other Scheme details:
85 * `#t` is true and `#f` is false
86 * `(lambda () ...)` constructs a thunk
87 * `'(1 . 2)` and `(cons 1 2)` are pairs (the same pair)
88 * `(list)` and `'()` both evaluate to the empty list
89 * `(null? lst)` tests whether `lst` is the empty list
90 * non-empty lists are implemented as pairs whose second member is a list
91 * `'()` `'(1)` `'(1 2)` `'(1 2 3)` are all lists
92 * `(list)` `(list 1)` `(list 1 2)` `(list 1 2 3)` are the same lists
93 * `'(1 2 3)` and `(cons 1 '(2 3))` are both pairs and lists (the same list)
94 * `(pair? lst)` tests whether `lst` is a pair; if `lst` is a non-empty list, it will also pass this test; if `lst` fails this test, it may be because `lst` is the empty list, or because it's not a list or pair at all
95 * `(car lst)` extracts the first member of a pair / head of a list
96 * `(cdr lst)` extracts the second member of a pair / tail of a list
98 Here is the implementation:
100 (define (lazy-flatten tree)
101 (letrec ([helper (lambda (tree tailk)
104 (helper (car tree) (lambda () (helper (cdr tree) tailk)))]
105 [else (cons tree tailk)]))])
106 (helper tree (lambda () (list)))))
108 (define (stream-equal? stream1 stream2)
110 [(and (null? stream1) (null? stream2)) #t]
111 [(and (pair? stream1) (pair? stream2))
112 (and (equal? (car stream1) (car stream2))
113 (stream-equal? ((cdr stream1)) ((cdr stream2))))]
116 (define (same-fringe? tree1 tree2)
117 (stream-equal? (lazy-flatten tree1) (lazy-flatten tree2)))
119 (define tree1 '(((1 . 2) . (3 . 4)) . (5 . 6)))
120 (define tree2 '(1 . (((2 . 3) . (4 . 5)) . 6)))
122 (same-fringe? tree1 tree2)