From c5d481fb6e394b6d439cca2928e07a38e758d357 Mon Sep 17 00:00:00 2001
From: jim
Date: Thu, 23 Apr 2015 11:29:48 0400
Subject: [PATCH] should be moreorless ready

exercises/_assignment12.mdwn  370 +++++++++++++++++++++++++++
1 file changed, 235 insertions(+), 135 deletions()
diff git a/exercises/_assignment12.mdwn b/exercises/_assignment12.mdwn
index f09556f0..2af65136 100644
 a/exercises/_assignment12.mdwn
+++ b/exercises/_assignment12.mdwn
@@ 1,135 +1,235 @@
1. Complete the definitions of `move_botleft` and `move_right_or_up` from the samefringe 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_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 *)
 (* 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 *)


 let new_zipper (t : 'a tree) : 'a zipper =
 {level = Root; filler = t}
 ;;



 let make_fringe_enumerator (t: 'a tree) =
 (* 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
  Some z > (
 (* extract label of currentlytargetted leaf *)
 let Leaf current = z.filler
 (* update zcell to point to next leaf, if there is one *)
 in let () = zcell := match move_right_or_up z with
  None > None
  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
 ;;

 let same_fringe (t1 : 'a tree) (t2 : 'a tree) : bool =
 let next1 = make_fringe_enumerator t1
 in let next2 = make_fringe_enumerator t2
 in let rec loop () : bool =
 match next1 (), next2 () with
  Some a, Some b when a = b > loop ()
  None, None > true
  _ > false
 in loop ()
 ;;


2. Here's another implementation of the samefringe function, in Scheme. It's taken from . 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 (`tailthunk` 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;

 (cond
 ((test1 argument argument) result1)
 ((test2 argument argument) result2)
 ((test3 argument argument) result3)
 (else result4))

 is equivalent to:

 (if (test1 argument argument)
 ; then
 result1
 ; else
 (if (test2 argument argument)
 ; then
 result2
 ; else
 (if (test3 argument argument)
 ; then
 result3
 ; else
 result4)))

 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
 * nonempty 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 as the preceding
 * `'(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 nonempty 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

 Here is the implementation:

 (define (lazyflatten tree)
 (letrec ([helper (lambda (tree tailthunk)
 (cond
 [(pair? tree)
 (helper (car tree) (lambda () (helper _____ tailthunk)))]
 [else (cons tree tailthunk)]))])
 (helper tree (lambda () _____))))

 (define (streamequal? stream1 stream2)
 (cond
 [(and (null? stream1) (null? stream2)) _____]
 [(and (pair? stream1) (pair? stream2))
 (and (equal? (car stream1) (car stream2))
 _____)]
 [else #f]))

 (define (samefringe? tree1 tree2)
 (streamequal? (lazyflatten tree1) (lazyflatten tree2)))

 (define tree1 '(((1 . 2) . (3 . 4)) . (5 . 6)))
 (define tree2 '(1 . (((2 . 3) . (4 . 5)) . 6)))

 (samefringe? tree1 tree2)


+1. Complete the definitions of `move_botleft` and `move_right_or_up` from the samefringe solution in [[this week's notes/topics/week12_list_and_tree_zippers]]. **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_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 new_zipper (t : 'a tree) : 'a zipper =
+ {level = Root; filler = t}
+
+ 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 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 *)
+
+
+
+
+
+ let make_fringe_enumerator (t: 'a tree) : 'b * 'a zipper option =
+ (* create a zipper targetting the botleft of t *)
+ let zbotleft = move_botleft (new_zipper t) in
+ (* create initial state, pointing to zbotleft *)
+ let initial_state = Some zbotleft in
+ (* construct the next_leaf function *)
+ let next_leaf : 'a zipper option > ('a * 'a zipper option) option = function
+  Some z > (
+ (* extract label of currentlytargetted leaf *)
+ let Leaf current = z.filler in
+ (* create next_state pointing to next leaf, if there is one *)
+ let next_state : 'a zipper option = match move_right_or_up z with
+  None > None
+  Some z' > Some (move_botleft z') in
+ (* return saved label and next_state *)
+ Some (current, next_state)
+ )
+  None > (* we've finished enumerating the fringe *)
+ None in
+ (* return the next_leaf function and initial state *)
+ next_leaf, initial_state
+
+ let same_fringe (t1 : 'a tree) (t2 : 'a tree) : bool =
+ let next1, initial_state1 = make_fringe_enumerator t1 in
+ let next2, initial_state2 = make_fringe_enumerator t2 in
+ let rec loop state1 state2 : bool =
+ match next1 state1, next2 state2 with
+  Some (a, state1'), Some (b, state2') when a = b > loop state1' state2'
+  None, None > true
+  _ > false in
+ loop initial_state1 initial_state2
+
+
+2. Now we'll talk about another way to implement the `make_fringe_enumerator` function above (and so too the `same_fringe` function which uses it). Notice that the pattern given above is that the `make_fringe_enumerator` creates a `process` function and an initial state, and each time you want to advance the `process` by one step, you do so by calling it with the current state. It will return a result plus a modified state, which you can use when you want to call it again and take another step. All of the `process` function's memory about where it is in the enumeration is contained in the state. If you saved an old state, took three steps, and then called the `process` function again with the saved old state, it would be back where it was three steps ago. But in fact, the way we use the process and state above, there is no backtracking. Neither do we "fork" any of the states and pursue different forward paths. Their progress is deterministic, and fixed independently of anything that `same_fringe` might do. All that's up to `same_fringe` is to take the decision of when (and whether) to take another step forward.
+
+ Given that usage pattern, it would be appropriate and convenient to make the `process` function remember its state itself, in a mutable variable. The client function `same_fringe` doesn't need to do anything with, or even be given access to, this variable. Here's how we might write `make_fringe_enumerator` according to this plan:
+
+ let make_fringe_enumerator (t: 'a tree) =
+ (* create a zipper targetting the botleft of t *)
+ let zbotleft = move_botleft (new_zipper t) in
+ (* create refcell, initially pointing to zbotleft *)
+ let zcell = ref (Some zbotleft) in
+ (* construct the next_leaf function *)
+ let next_leaf () : 'a option =
+ match !zcell with
+  Some z > (
+ (* extract label of currentlytargetted leaf *)
+ let Leaf current = z.filler in
+ (* update zcell to point to next leaf, if there is one *)
+ let () = zcell := match move_right_or_up z with
+  None > None
+  Some z' > _____ in
+ (* return saved label *)
+ _____
+ )
+  None > (* we've finished enumerating the fringe *)
+ None in
+ (* return the next_leaf function *)
+ next_leaf
+
+ let same_fringe (t1 : 'a tree) (t2 : 'a tree) : bool =
+ let next1 = make_fringe_enumerator t1 in
+ let next2 = make_fringe_enumerator t2 in
+ let rec loop () : bool =
+ match _____, _____ with
+  Some a, Some b when a = b > loop ()
+  None, None > true
+  _ > false in
+ loop ()
+
+ You should fill in the blanks.
+
+
+
+
+3. Here's another implementation of the samefringe function, in Scheme. It's taken from . 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 (`tailthunk` 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;
+
+ (cond
+ ((test1 argument argument) result1)
+ ((test2 argument argument) result2)
+ ((test3 argument argument) result3)
+ (else result4))
+
+ is equivalent to:
+
+ (if (test1 argument argument)
+ ; then
+ result1
+ ; else
+ (if (test2 argument argument)
+ ; then
+ result2
+ ; else
+ (if (test3 argument argument)
+ ; then
+ result3
+ ; else
+ result4)))
+
+ Some other Scheme details or reminders:
+
+ * `#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
+ * nonempty 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 as the preceding
+ * `'(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 nonempty 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
+
+ Here is the implementation:
+
+ (define (lazyflatten tree)
+ (letrec ([helper (lambda (tree tailthunk)
+ (cond
+ [(pair? tree)
+ (helper (car tree) (lambda () (helper _____ tailthunk)))]
+ [else (cons tree tailthunk)]))])
+ (helper tree (lambda () _____))))
+
+ (define (streamequal? stream1 stream2)
+ (cond
+ [(and (null? stream1) (null? stream2)) _____]
+ [(and (pair? stream1) (pair? stream2))
+ (and (equal? (car stream1) (car stream2))
+ _____)]
+ [else #f]))
+
+ (define (samefringe? tree1 tree2)
+ (streamequal? (lazyflatten tree1) (lazyflatten tree2)))
+
+ (define tree1 '(((1 . 2) . (3 . 4)) . (5 . 6)))
+ (define tree2 '(1 . (((2 . 3) . (4 . 5)) . 6)))
+
+ (samefringe? tree1 tree2)
+
+The previous problem implemented a "stream" in Scheme. A stream is like a list in that it wraps a series of elements of a single type. It differs from a list in that the tail of the series is left uncomputed until needed. We will turn the stream on and off by thunking it. Here is one way to implement streams in OCaml:
+
+ type 'a stream = End  Next of 'a * (unit > 'a stream);;
+
+There is a special stream called End that represents a stream that contains no (more) elements, analogous to the empty list []. Streams that are not empty contain a first object, paired with a thunked stream representing the rest of the series. In order to get access to the next element in the stream, we must force the thunk by applying it to the unit. Watch the behavior of this stream in detail. This stream delivers the natural numbers, in order: 1, 2, 3, ...
+
+ # let rec make_int_stream i = Next (i, fun () > make_int_stream (i + 1));;
+ val make_int_stream : int > int stream = [fun]
+
+ # let int_stream = make_int_stream 1;;
+ val int_stream : int stream = Next (1, [fun]) (* First element: 1 *)
+
+ # let tail = match int_stream with Next (i, rest) > rest;;
+ val tail : unit > int stream = [fun] (* Tail: a thunk *)
+
+ (* Force the thunk to compute the second element *)
+ # tail ();;
+  : int stream = Next (2, [fun]) (* Second element: 2 *)
+
+ # match tail () with Next (_, rest) > rest ();;
+  : int stream = Next (3, [fun]) (* Third element: 3 *)
+
+You can think of `int_stream` as a functional object that provides access to an infinite sequence of integers, one at a time. It's as if we had written `[1;2;...]` where `...` meant "continue for as long as some other process needs new integers".

2.11.0