Some other Scheme details:
* `#t` is true and `#f` is false
+ * `(lambda () ...)` constructs a thunk
+ * there is no difference in meaning between `[...]` and `(...)`; we just sometimes use the square brackets for clarity
+ * `'(1 . 2)` and `(cons 1 2)` are pairs (the same pair)
* `(list)` and `'()` both evaluate to the empty list
* `(null? lst)` tests whether `lst` is the empty list
+ * non-empty lists are implemented as pairs whose second member is a list
+ * `'()` `'(1)` `'(1 2)` `'(1 2 3)` are all lists
+ * `(list)` `(list 1)` `(list 1 2)` `(list 1 2 3)` are the same lists
+ * `'(1 2 3)` and `(cons 1 '(2 3))` are both pairs and lists (the same list)
* `(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
* `(car lst)` extracts the first member of a pair / head of a list
* `(cdr lst)` extracts the second member of a pair / tail of a list
- * `(lambda () ...)` constructs a thunk
Here is the implementation:
(cond
[(pair? tree)
(helper (car tree) (lambda () (helper (cdr tree) tailk)))]
- [(null? tree) (tailk)]
[else (cons tree tailk)]))])
(helper tree (lambda () (list)))))
(define (same-fringe? tree1 tree2)
(stream-equal? (lazy-flatten tree1) (lazy-flatten tree2)))
- (define tree1 '(((1 2) (3 4)) (5 6)))
- (define tree2 '(1 (((2 3) (4 5)) 6)))
+ (define tree1 '(((1 . 2) . (3 . 4)) . (5 . 6)))
+ (define tree2 '(1 . (((2 . 3) . (4 . 5)) . 6)))
(same-fringe? tree1 tree2)