author Jim Pryor Thu, 16 Dec 2010 13:57:03 +0000 (08:57 -0500) committer Jim Pryor Thu, 16 Dec 2010 13:57:03 +0000 (08:57 -0500)
Signed-off-by: Jim Pryor <profjim@jimpryor.net>

index c6cc2d5..97d2098 100644 (file)

-This problem is taken from _The Craft of Functional Programming_ by Simon Thompson, Addison-Wesley 1999 <http://www.cs.kent.ac.uk/people/staff/sjt/>:
+1.     This problem is taken from _The Craft of Functional Programming_ by Simon Thompson, Addison-Wesley 1999 <http://www.cs.kent.ac.uk/people/staff/sjt/>:

->      Given an arbitrary tree, transform it to a
->      tree of integers in which the original elements are replaced by
->      natural numbers, starting from 0.  The same element has to be
->      replaced by the same number at every occurrence, and when we meet
->      an as-yet-unvisited element we have to find a "new" number to match
->      it with.
+       >       Given an arbitrary tree, transform it to a
+       >       tree of integers in which the original elements are replaced by
+       >       natural numbers, starting from 0.  The same element has to be
+       >       replaced by the same number at every occurrence, and when we meet
+       >       an as-yet-unvisited element we have to find a "new" number to match
+       >       it with.

-Here is [a hint](/hints/assignment_10_hint).
+       Here is [a hint](/hints/assignment_10_hint).
+
+
+2.     Armed with your solution to problem 1, try this: you have as input a lead-labeled, binary tree whose labels are strings. You also have as input an interpretation function from strings to meanings. Let the meanings of your strings be primitive elements, for instance:
+
+               type meaning = John | Bill | Sally | Zachariah | Swam | Likes | ...
+
+       If you want to get fancy and have different strings be interpreted to meanings of different types, go ahead. But that won't be essential to this problem. What is essential is that sometimes different strings might map onto the same meaning. For instance, both `"John"` and `"Hannes"` might map to `John`.
+
+       Your task is to return a tree with the same structure as the original tree, but with all string labels replaced with a pair of a meaning and an int. The meaning should be the meaning your interpretation function assigns to the string. Two leaves that get the same meaning should get the same int as well iff the leaves originally were labelled with the same string. So if `"John"` is replaced with `(John, 1)`, then `"Hannes"` should be replaced with `(John, j)` where `j` is an `int` other than `1`. We don't care whether you ever use the same `int`s for leafs with different associated meanings.
+
+       If you solve this, congratulations! You're most of the way to implementing a hyper-evaluative semantics, of the sort Jim discussed around Week 10.
+
+3.     Our notes on [[monad transformers]] give you most of the pieces you need to implement a StateT monad transformer. The only crucial piece that's missing is a definition for StateT's `elevate` function. Here are the earlier pieces repeated, together with that missing piece:
+
+               type 'a stateT(M) =
+                 store -> ('a * store) M;;
+
+               let unit (a : 'a) : 'a stateT(M) =
+                 fun s -> M.unit (a, s);;
+                 (* can in general be defined as `fun a -> elevate (M.unit a)` *)
+
+               let bind (u : 'a stateT(M)) (f : 'a -> 'b stateT(M)) : 'b stateT(M) =
+                 fun s -> M.bind (u s) (fun (a, s') -> f a s');;
+
+               let elevate (m : 'a M) : 'a stateT(M) =
+                 fun s -> Wrapped.bind w (fun a -> Wrapped.unit (a, s));;
+
+       That won't compile in OCaml because we use the `M`s in a way that's intuitive but unrecognized by OCaml. What OCaml will recognize is more complex. Don't worry; you won't need to code a general implementation of StateT.
+
+       What we do want you to do is to implement StateT(List). That is, plug in the implementations of the List monad's type, unit, and bind into the preceding definitions. That will be a monad, consisting of an inner List monad with StateT packaging around it. Choose sensible names for the type, and unit, bind, and elevant functions of your StateT(List) monad.
+
+       You may want to write some operations for your List monad, such as:
+
+               either (u : 'a list) (v : 'a list) : 'a list
+               (* appends list v to list u *)
+
+               foreach (u : 'a list) (v : 'a list) : 'a list
+               (* returns a list of lists, each member of which consists of u followed
+                 by a single member of v; there is one for each member of v *)
+
+       and so on. These are just suggestions; you decide which List operations you'll need. For each of these, use your StateT(List)'s `elevate` function to convert them into operations in your combined, State-around-List monad.
+
+       Now, go back to the GS&V assignment from [[assignment7]]. Does the monad you've now crafted enable you to code your implementation of that semantics more elegantly? You can begin by using a composite store of the same sort we used in the hints: a pair of an assignment function `r` and some `h` that associates pegs with entities.
+
+Is the `h` really essential to your solution? Or could you do everything with a store consisting of a single mapping from variables to entities? (You'd still be working with a State monad, but without the pegs.) Explain why or why not.
+
+4.     The next two exercises were taken from _The Little Schemer_ Chapter 8.
+
+               Suppose `lst` is a list of Scheme symbols (`'symbols 'are 'things 'written 'like 'this`; a list of them is `'(written like this)`). And that the behavior of `(remove 'sym lst)` is to remove every occurrence of `'sym` from `lst`.
+
+       Now we define a function `remove-co` which has the following behavior. It accepts as arguments a symbol, a list, and a handler `k` (I wonder why we named it that). `remove-co` calls `k` with two arguments: first, a list of all the sumbols in `lst` that aren't equal to `'sym`, and second, a list of all the symbols in `lst` that are equal to `'sym` (the handler might want to, for example, see what the length of the latter list is).
+
+       Here is a partial implementation. You should fill in the blanks. If you get stuck, you can consult the walkthough in _The Little Schemer_, or talk to us.
+
+               (define remove-co
+                 (lambda (a lst k)
+                   (cond
+                     ((null? lst)
+                      (k ___  ___))
+                     ((eq? (car lst) a)
+                      (remove-co a (cdr lst) (lambda (left right) ________)))
+                     (else
+                      (remove-co a (cdr lst) (lambda (left right) ________))))))
+
+       What would be a helper function you could supply as a `k` that would report `#t` iff the original `lst` contained more instances of some symbol than non-instances?
+
+5.     Now we define a function `insert-co` which has the following behavior. It accepts as arguments three symbols, a list, and a handler. The first symbol is inserted before (to the left of) any occurrences in the list of the second symbol, and after (to the right of) any occurrences of the third symbol. The handler is then called with three arguments: the new list (with the insertions made), the number of "to-the-left" insertions that were made, and the number of "to-the-right" insertions that were made.
+
+       Here is a partial implementation. You should fill in the blanks. If you get stuck, you can consult the walkthough in _The Little Schemer_, or talk to us.
+
+               (define insert-co
+                 (lambda (new before after lst k)
+                   (cond
+                     ((null? lst)
+                      (k ___  ___ ___))
+                     ((eq? (car lst) before)
+                      (insert-co new before after (cdr lst) (lambda (new-lst lefts rights) ________)))
+                     ((eq? (car lst) after)
+                      (insert-co new before after (cdr lst) (lambda (new-lst lefts rights) ________)))
+                     (else
+                      (insert-co new before after (cdr lst) (lambda (new-lst lefts rights) ________))))))
+
+
+6.     Go back to the "abSd" problem we presented in [[From List Zippers to Continuations]]. Consider the "tc" solution which uses explicitly passed continuations. Try to reimplement this using reset and shift instead of having an explicit `k` argument. This will likely be challenging but rewarding. The notes on [[CPS and Contunuation Operators]], especially the examples at the end, should be helpful. We are of course also glad to help you out.
+
+7.     Can you reimplement your solution to [[assignment9]] using reset and shift?
+
+These are challenging questions, don't get frustrated if you get stuck, seek help.
+