+7. Write a recursive function to make a copy of a `color_tree` with the same structure and inner branch colors, but where the leftmost leaf is now labeled `0`, the second-leftmost leaf is now labeled `1`, and so on.
+
+8. (More challenging.) Write a recursive function that makes a copy of a `color_tree` with the same structure and inner branch colors, but replaces each leaf label with the `int` that reports how many of that leaf's ancestors are labeled `Red`. For example, if we give your function a tree:
+
+ <pre>
+ Red
+ / \
+ Blue \
+ / \ Green
+ a b / \
+ c Red
+ / \
+ d e
+ </pre>
+
+ (for any leaf values `a` through `e`), it should return:
+
+ <pre>
+ Red
+ / \
+ Blue \
+ / \ Green
+ 1 1 / \
+ 1 Red
+ / \
+ 2 2
+ </pre>
+
+9. (More challenging.) Assume you have a `color_tree` whose leaves are labeled with `int`s (which may be negative). For this problem, assume also that the the same color never labels multiple inner branches. Write a recursive function that reports which color has the greatest "score" when you sum up all the values of its descendent leaves. Since some leaves may have negative values, the answer won't always be the color at the tree root. In the case of ties, you can return whichever of the highest scoring colors you like.
+
+
+## Search Trees ##
+
+(More challenging.) For the next problem, assume the following type definition:
+
+ (* OCaml *)
+ type search_tree = Nil | Inner of search_tree * int * search_tree
+
+ -- Haskell
+ data Search_tree = Nil | Inner Search_tree Int Search_tree deriving (Show)
+
+That is, its leaves have no labels and its inner nodes are labeled with `int`s. Additionally, assume that all the `int`s in branches descending to the left from a given node will be less than the `int` of that parent node, and all the `int`s in branches descending to the right will be greater. We can't straightforwardly specify this constraint in OCaml's or Haskell's type definitions. We just have to be sure to maintain it by hand.
+
+10. Write a function `search_for` with the following type, as displayed by OCaml:
+
+ type direction = Left | Right
+ search_for : int -> search_tree -> direction list option
+
+ Haskell would say instead:
+
+ data Direction = Left | Right deriving (Eq, Show)
+ search_for :: Int -> Search_tree -> Maybe [Direction]
+
+ Your function should search through the tree for the specified `int`. If it's never found, it should return the value OCaml calls `None` and Haskell calls `Nothing`. If it finds the `int` right at the root of the `search_tree`, it should return the value OCaml calls `Some []` and Haskell calls `Just []`. If it finds the `int` by first going down the left branch from the tree root, and then going right twice, it should return `Some [Left; Right; Right]` or `Just [Left, Right, Right]`.
+
+
+## More Map2s ##
+
+Above, you defined `maybe_map2` [WHERE]. Before we encountered `map2` for lists. There are in fact several different approaches to mapping two lists together.
+
+11. One approach is to apply the supplied function to the first element of each list, and then to the second element of each list, and so on, until the lists are exhausted. If the lists are of different lengths, you might stop with the shortest, or you might raise an error. Different implementations make different choices about that. Let's call this function:
+
+ (* OCaml *)
+ map2_zip : ('a -> 'b -> 'c) -> ('a) list -> ('b) list -> ('c) list
+
+ Write a recursive function that implements this, in Haskell or OCaml. Let's say you can stop when the shorter list runs out, if they're of different lengths. (OCaml and Haskell each already have functions in their standard libraries --- `map2` or `zipWith` -- that do this. And it also corresponds to a list comprehension you can write in Haskell like this:
+
+ :set -XParallelListComp
+ [ f x y | x <- xs | y <- ys ]
+
+ <!-- or `f <$/fmap> ZipList xs <*/ap> ZipList ys`; or `pure f <*> ...`; or `liftA2 f (ZipList xs) (ZipList ys)` -->
+ But we want you to write this function from scratch.)
+
+12. What is the relation between the function you just wrote, and the `maybe_map2` function you wrote for problem 2, above?
+
+13. Another strategy is to take the *cross product* of the two lists. If the function:
+
+ (* OCaml *)
+ map2_cross : ('a -> 'b -> 'c) -> ('a) list -> ('b) list -> ('c) list
+
+ is applied to the arguments `f`, `[x0, x1, x2]`, and `[y0, y1]`, then the result should be: `[f x0 y0, f x0 y1, f x1 y0, f x1 y1, f x2 y0, f x2 y1]`. Write this function.
+ <!-- in Haskell, `liftA2 f xs ys` -->
+
+A similar choice between "zipping" and "crossing" could be made when `map2`-ing two trees. For example, the trees:
+
+<pre>
+ 0 5
+ / \ / \
+ 1 2 6 7
+ / \ / \
+ 3 4 8 9
+</pre>
+
+could be "zipped" like this (ignoring any parts of branches on the one tree that extend farther than the corresponding branch on the other):
+
+<pre>
+ f 0 5
+ / \
+f 1 6 f 2 7
+</pre>
+
+14. You can try defining that if you like, for extra credit.
+
+"Crossing" the trees would instead add copies of the second tree as subtrees replacing each leaf of the original tree, with the leaves of that larger tree labeled with `f` applied to `3` and `6`, then `f` applied to `3` and `8`, and so on across the fringe of the second tree; then beginning again (in the subtree that replaces the `4` leaf) with `f` applied to `4` and `6`, and so on.
+
+* In all the plain `map` functions, whether for lists, or for `option`/`Maybe`s, or for trees, the structure of the result exactly matched the structure of the argument.
+
+* In the `map2` functions, whether for lists or for `option`/`Maybe`s or for trees, and whether done in the "zipping" style or in the "crossing" style, the structure of the result may be a bit different from the structure of the arguments. But the *structure* of the arguments is enough to determine the structure of the result; you don't have to look at the specific list elements or labels on a tree's leaves or nodes to know what the *structure* of the result will be.
+
+* We can imagine more radical transformations, where the structure of the result *does* depend on what specific elements the original structure(s) had. For example, what if we had to transform a tree by turning every leaf into a subtree that contained all of those leaf's prime factors? Or consider our problem from last week [WHERE] where you converted `[3, 2, 0, 1]` not into `[[3,3,3], [2,2], [], [1]]` --- which still has the same structure, that is length, as the original --- but rather into `[3, 3, 3, 2, 2, 1]` --- which doesn't.
+ (Some of you had the idea last week to define this last transformation in Haskell as `[x | x <- [3,2,0,1], y <- [0..(x-1)]]`, which just looks like a cross product, that we counted under the *previous* bullet point. However, in that expression, the second list's structure depends upon the specific values of the elements in the first list. So it's still true, as I said, that you can't specify the structure of the output list without looking at those elements.)
+
+These three levels of how radical a transformation you are making to a structure, and the parallels between the transformations to lists, to `option`/`Maybe`s, and to trees, will be ideas we build on in coming weeks.
+
+
+
+
+
+## Untyped Lambda Terms ##
+
+In OCaml, you can define some datatypes that represent terms in the untyped Lambda Calculus like this:
+
+ type identifier = string
+ type lambda_term = Var of identifier | Abstract of identifier * _____ | App of _____
+
+We've left some gaps.
+
+In Haskell, you'd define it instead like this:
+
+ type Identifier = String
+ data Lambda_term = Var Identifier | Abstract Identifier _____ | App ________
+
+15. Again, we've left some gaps. Choose one of these languages and fill in the gaps to complete the definition.
+
+16. Write a function `occurs_free` that has the following type:
+
+ occurs_free : identifier -> lambda_term -> bool
+
+ That's how OCaml would show it. Haskell would use double colons `::` instead, and would also capitalize all the type names. Your function should tell us whether the supplied identifier ever occurs free in the supplied `lambda_term`.
+
+
+
+
+## Encoding Booleans, Church numerals, and Right-Fold Lists in System F ##
+
+<!-- These questions are adapted from web materials by Umut Acar. Were at <http://www.mpi-sws.org/~umut/>. Now he's moved to <http://www.umut-acar.org/> and I can't find the page anymore. -->
+
+
+(For the System F questions, you can either work on paper, or download and compile Pierce's evaluator for system F to test your work [WHERE].)