From 10801f102209b822c0bf5a802f9c3c50ca40b18c Mon Sep 17 00:00:00 2001
From: Chris <chris.barker@nyu.edu>
Date: Fri, 3 Apr 2015 16:54:19 -0400
Subject: [PATCH] exercises

---
 exercises/_assignment8.mdwn | 100 ++++++++++++++------------------------------
 1 file changed, 31 insertions(+), 69 deletions(-)

diff --git a/exercises/_assignment8.mdwn b/exercises/_assignment8.mdwn
index 1c7fdfaf..cd1dc089 100644
--- a/exercises/_assignment8.mdwn
+++ b/exercises/_assignment8.mdwn
@@ -1,84 +1,46 @@
-
 Binding more than one variable at a time
 ----------------------------------------
 
-It requires some cleverness to use the link monad to bind more than
-one variable at a time.  Whereas in the standard Reader monad a single
-environment can record any number of variable assignments, because
-Jacobson's monad only tracks a single dependency, binding more than
-one pronoun requires layering the monad.  (Jacobson provides some
-special combinators, but we can make do with the ingredients already
-defined.)
-
-Let's take the following sentence as our target, with the obvious
-binding relationships:
-
-<pre>
-    John believes Mary said he thinks she's cute.
-     |             |         |         |
-     |             |---------|---------|
-     |                       |
-     |-----------------------|
-</pre>
-
-It will be convenient to
-have a counterpart to the lift operation that combines a monadic
-functor with a non-monadic argument:
-
-<pre>
-    let g f v = ap (unit f) v;;
-    let g2 u a = ap u (unit a);;
-</pre>
-
-As a first step, we'll bind "she" by "Mary":
+1. Jacobson's reader monad only allows for establishing a single binding
+relationship at a time.  It requires considerable cleverness to deploy
+her combinators in a way that establishes multiple binding
+relationships, as in 
 
-<pre>
-believes (z said (g2 (g thinks (g cute she)) she) mary) john
+    John_x thinks Mary_y said he_x likes her_y.
 
-~~> believes (said (thinks (cute mary) he) mary) john
-</pre>
+See her 1999 paper for details.
 
-As usual, there is a trail of *g*'s leading from the pronoun up to the
-*z*.  Next, we build a trail from the other pronoun ("he") to its
-binder ("John").  
+Here is [[code for the simple arithmetic reader monad discussed in the
+lecture notes|code/arithmetic1.ml]]. It computes
+`\x. (+ 1 (* (/ 6 x) 4))`.  Your task is to modify it to compute
+`\x\y.(+ 1 (* (/ 6 x) y))`.  You will need to modify five lines.
+The first one is the type of a boxed int.  Instead of `type num = int
+-> int`, you'll need
 
-<pre>
-believes
-  said 
-    thinks (cute she) he
-    Mary
-  John
+    type num = int -> int -> int
 
-believes
-  z said
-    (g2 ((g thinks) (g cute she))) he
-    Mary
-  John
+The second and third are the definitions of mid and map2.  The fourth
+is the one that encodes the variable x, the line that begins `(Leaf
+(Num (fun x -> ...`.  The fifth line you need to modify is the one
+that replaces "4" with "y".  When you have these lines modified,
+you should be able to execute the following expression:
 
-z believes
-  (g2 (g (z said)
-         (g (g2 ((g thinks) (g cute she))) 
-            he))
-      Mary)
-  John
-</pre>
+    # match eval t2 with Leaf (Num f) -> f 2 4;;
+    - : int = 13
 
-In the first interation, we build a chain of *g*'s and *g2*'s from the
-pronoun to be bound ("she") out to the level of the first argument of
-*said*. 
+2. Based on the evaluator code from the assignment from week 7,
+enhance the code to handle an arbitrary set of free variables.  
+Return to the original code (before executing the modifications
+required by exercise 1).
 
-In the second iteration, we treat the entire structure as ordinary
-functions and arguments, without "seeing" the monadic region.  Once
-again, we build a chain of *g*'s and *g2*'s from the currently
-targeted pronoun ("he") out to the level of the first argument of
-*believes*.  (The new *g*'s and *g2*'s are the three leftmost).
+Start like this:
 
-<pre>
-z believes (g2 (g (z said) (g (g2 ((g thinks) (g cute she))) he)) mary) john
+    type env = string -> int
+    type num = env -> int
+    let g = fun var -> match var with "x" -> 2 | "y" -> 4 | _ -> 0;;
 
-~~> believes (said (thinks (cute mary) john) mary) john
-</pre>
+When you have it working, try
 
-Obviously, we can repeat this strategy for any configuration of pronouns
-and binders.
+    # match eval t2 with Leaf (Num f) -> f g;;
+    - : int = 13
 
-- 
2.11.0