```-# fun f z -> z;;
-- : 'a -> 'b -> 'b =
-# fun f z -> f 1 z;;
-- : (int -> 'a -> 'b) -> 'a -> 'b =
-# fun f z -> f 2 (f 1 z);;
-- : (int -> 'a -> 'a) -> 'a -> 'a =
-# fun f z -> f 3 (f 2 (f 1 z))
-- : (int -> 'a -> 'a) -> 'a -> 'a =
-```
```-# let cons h t = h :: t;;  (* Ocaml is stupid about :: *)
-# l'_bind (fun f z -> f 1 (f 2 z))
-          (fun i -> fun f z -> f i (f (i+1) z)) cons [];;
-- : int list = [1; 2; 2; 3]
-```
+ # let cons h t = h :: t;; (* OCaml is stupid about :: *) + # l'_bind (fun f z -> f 1 (f 2 z)) + (fun i -> fun f z -> f i (f (i+1) z)) cons [];; + - : int list = [1; 2; 2; 3] Ta da! -To bad this digression, though it ties together various -elements of the course, has *no relevance whatsoever* to the topic of -continuations... Montague's PTQ treatment of DPs as generalized quantifiers ---------------------------------------------------------- @@ -263,46 +328,588 @@ generalized quantifier `fun pred -> pred j` of type `(e -> t) -> t`. Let's write a general function that will map individuals into their corresponding generalized quantifier: - gqize (x:e) = fun (p:e->t) -> p x + gqize (a : e) = fun (p : e -> t) -> p a + +This function is what Partee 1987 calls LIFT, and it would be +reasonable to use it here, but we will avoid that name, given that we +use that word to refer to other functions. -This function wraps up an individual in a fancy box. That is to say, +This function wraps up an individual in a box. That is to say, we are in the presence of a monad. The type constructor, the unit and the bind follow naturally. We've done this enough times that we won't belabor the construction of the bind function, the derivation is -similar to the List monad just given: +highly similar to the List monad just given: -
```-type 'a continuation = ('a -> 'b) -> 'b
-c_unit (x:'a) = fun (p:'a -> 'b) -> p x
-c_bind (u:('a -> 'b) -> 'b) (f: 'a -> ('c -> 'd) -> 'd): ('c -> 'd) -> 'd =
-  fun (k:'a -> 'b) -> u (fun (x:'a) -> f x k)
-```
```+let t1 = Node ((Node ((Leaf 2), (Leaf 3))),
+               (Node ((Leaf 5),(Node ((Leaf 7),
+                                      (Leaf 11))))))
+
+    .
+ ___|___
+ |     |
+ .     .
+_|__  _|__
+|  |  |  |
+2  3  5  .
+        _|__
+        |  |
+        7  11
+```
+ +Our first task will be to replace each leaf with its double: + +
```+let rec treemap (newleaf:'a -> 'b) (t:'a tree):('b tree) =
+  match t with Leaf x -> Leaf (newleaf x)
+             | Node (l, r) -> Node ((treemap newleaf l),
+                                    (treemap newleaf r));;
+```
+`treemap` takes a function that transforms old leaves into new leaves, +and maps that function over all the leaves in the tree, leaving the +structure of the tree unchanged. For instance: + +
```+let double i = i + i;;
+treemap double t1;;
+- : int tree =
+Node (Node (Leaf 4, Leaf 6), Node (Leaf 10, Node (Leaf 14, Leaf 22)))
+
+    .
+ ___|____
+ |      |
+ .      .
+_|__  __|__
+|  |  |   |
+4  6  10  .
+        __|___
+        |    |
+        14   22
+```
+ +We could have built the doubling operation right into the `treemap` +code. However, because what to do to each leaf is a parameter, we can +decide to do something else to the leaves without needing to rewrite +`treemap`. For instance, we can easily square each leaf instead by +supplying the appropriate `int -> int` operation in place of `double`: + +
```+let square x = x * x;;
+treemap square t1;;
+- : int tree =ppp
+Node (Node (Leaf 4, Leaf 9), Node (Leaf 25, Node (Leaf 49, Leaf 121)))
+```
+ +Note that what `treemap` does is take some global, contextual +information---what to do to each leaf---and supplies that information +to each subpart of the computation. In other words, `treemap` has the +behavior of a reader monad. Let's make that explicit. + +In general, we're on a journey of making our treemap function more and +more flexible. So the next step---combining the tree transducer with +a reader monad---is to have the treemap function return a (monadized) +tree that is ready to accept any `int->int` function and produce the +updated tree. + +\tree (. (. (f2) (f3))(. (f5) (.(f7)(f11)))) +
```+\f    .
+  ____|____
+  |       |
+  .       .
+__|__   __|__
+|   |   |   |
+f2  f3  f5  .
+          __|___
+          |    |
+          f7  f11
+```
+ +That is, we want to transform the ordinary tree `t1` (of type `int +tree`) into a reader object of type `(int->int)-> int tree`: something +that, when you apply it to an `int->int` function returns an `int +tree` in which each leaf `x` has been replaced with `(f x)`. + +With previous readers, we always knew which kind of environment to +expect: either an assignment function (the original calculator +simulation), a world (the intensionality monad), an integer (the +Jacobson-inspired link monad), etc. In this situation, it will be +enough for now to expect that our reader will expect a function of +type `int->int`. + +
```+type 'a reader = (int->int) -> 'a;;  (* mnemonic: e for environment *)
+```
+ +It's easy to figure out how to turn an `int` into an `int reader`: + +
```+let int2int_reader (x:'a): 'b reader = fun (op:'a -> 'b) -> op x;;
+int2int_reader 2 (fun i -> i + i);;
+- : int = 4
+```
+ +But what do we do when the integers are scattered over the leaves of a +tree? A binary tree is not the kind of thing that we can apply a +function of type `int->int` to. + +
```+let rec treemonadizer (f:'a -> 'b reader) (t:'a tree):('b tree) reader =
+  match t with Leaf x -> reader_bind (f x) (fun x' -> reader_unit (Leaf x'))
+             | Node (l, r) -> reader_bind (treemonadizer f l) (fun x ->
+```
+ +This function says: give me a function `f` that knows how to turn +something of type `'a` into an `'b reader`, and I'll show you how to +turn an `'a tree` into an `'a tree reader`. In more fanciful terms, +the `treemonadizer` function builds plumbing that connects all of the +leaves of a tree into one connected monadic network; it threads the +monad through the leaves. + +
```+# treemonadizer int2int_reader t1 (fun i -> i + i);;
+- : int tree =
+Node (Node (Leaf 4, Leaf 6), Node (Leaf 10, Node (Leaf 14, Leaf 22)))
+```
+ +Here, our environment is the doubling function (`fun i -> i + i`). If +we apply the very same `int tree reader` (namely, `treemonadizer +int2int_reader t1`) to a different `int->int` function---say, the +squaring function, `fun i -> i * i`---we get an entirely different +result: + +
```+# treemonadizer int2int_reader t1 (fun i -> i * i);;
+- : int tree =
+Node (Node (Leaf 4, Leaf 9), Node (Leaf 25, Node (Leaf 49, Leaf 121)))
+```
+ +Now that we have a tree transducer that accepts a monad as a +parameter, we can see what it would take to swap in a different monad. +For instance, we can use a state monad to count the number of nodes in +the tree. + +
```+type 'a state = int -> 'a * int;;
+let state_unit x i = (x, i+.5);;
+let state_bind u f i = let (a, i') = u i in f a (i'+.5);;
+```
+ +Gratifyingly, we can use the `treemonadizer` function without any +modification whatsoever, except for replacing the (parametric) type +`reader` with `state`: + +
```+let rec treemonadizer (f:'a -> 'b state) (t:'a tree):('b tree) state =
+  match t with Leaf x -> state_bind (f x) (fun x' -> state_unit (Leaf x'))
+             | Node (l, r) -> state_bind (treemonadizer f l) (fun x ->
+                                state_bind (treemonadizer f r) (fun y ->
+                                  state_unit (Node (x, y))));;
+```
+ +Then we can count the number of nodes in the tree: + +
```+# treemonadizer state_unit t1 0;;
+- : int tree * int =
+(Node (Node (Leaf 2, Leaf 3), Node (Leaf 5, Node (Leaf 7, Leaf 11))), 13)
+
+    .
+ ___|___
+ |     |
+ .     .
+_|__  _|__
+|  |  |  |
+2  3  5  .
+        _|__
+        |  |
+        7  11
+```
+ +Notice that we've counted each internal node twice---it's a good +exercise to adjust the code to count each node once. + +One more revealing example before getting down to business: replacing +`state` everywhere in `treemonadizer` with `list` gives us + +
```+# treemonadizer (fun x -> [ [x; square x] ]) t1;;
+- : int list tree list =
+[Node
+  (Node (Leaf [2; 4], Leaf [3; 9]),
+   Node (Leaf [5; 25], Node (Leaf [7; 49], Leaf [11; 121])))]
+```
+ +Unlike the previous cases, instead of turning a tree into a function +from some input to a result, this transformer replaces each `int` with +a list of `int`'s. + +Now for the main point. What if we wanted to convert a tree to a list +of leaves? + +
```+type ('a, 'r) continuation = ('a -> 'r) -> 'r;;
+let continuation_unit x c = c x;;
+let continuation_bind u f c = u (fun a -> f a c);;
+
+let rec treemonadizer (f:'a -> ('b, 'r) continuation) (t:'a tree):(('b tree), 'r) continuation =
+  match t with Leaf x -> continuation_bind (f x) (fun x' -> continuation_unit (Leaf x'))
+             | Node (l, r) -> continuation_bind (treemonadizer f l) (fun x ->
+                                continuation_bind (treemonadizer f r) (fun y ->
+                                  continuation_unit (Node (x, y))));;
+```
+ +We use the continuation monad described above, and insert the +`continuation` type in the appropriate place in the `treemonadizer` code. +We then compute: + +
```+# treemonadizer (fun a c -> a :: (c a)) t1 (fun t -> []);;
+- : int list = [2; 3; 5; 7; 11]
+```
+ +We have found a way of collapsing a tree into a list of its leaves. + +The continuation monad is amazingly flexible; we can use it to +simulate some of the computations performed above. To see how, first +note that an interestingly uninteresting thing happens if we use the +continuation unit as our first argument to `treemonadizer`, and then +apply the result to the identity function: + +
```+# treemonadizer continuation_unit t1 (fun x -> x);;
+- : int tree =
+Node (Node (Leaf 2, Leaf 3), Node (Leaf 5, Node (Leaf 7, Leaf 11)))
+```
+ +That is, nothing happens. But we can begin to substitute more +interesting functions for the first argument of `treemonadizer`: + +
```+(* Simulating the tree reader: distributing a operation over the leaves *)
+# treemonadizer (fun a c -> c (square a)) t1 (fun x -> x);;
+- : int tree =
+Node (Node (Leaf 4, Leaf 9), Node (Leaf 25, Node (Leaf 49, Leaf 121)))
+
+(* Simulating the int list tree list *)
+# treemonadizer (fun a c -> c [a; square a]) t1 (fun x -> x);;
+- : int list tree =
+Node
+ (Node (Leaf [2; 4], Leaf [3; 9]),
+  Node (Leaf [5; 25], Node (Leaf [7; 49], Leaf [11; 121])))
+
+(* Counting leaves *)
+# treemonadizer (fun a c -> 1 + c a) t1 (fun x -> 0);;
+- : int = 5
+```
+ +We could simulate the tree state example too, but it would require +generalizing the type of the continuation monad to + + type ('a -> 'b -> 'c) continuation = ('a -> 'b) -> 'c;; + +The binary tree monad +--------------------- + +Of course, by now you may have realized that we have discovered a new +monad, the binary tree monad: + +
```+type 'a tree = Leaf of 'a | Node of ('a tree) * ('a tree);;
+let tree_unit (x:'a) = Leaf x;;
+let rec tree_bind (u:'a tree) (f:'a -> 'b tree):'b tree =
+  match u with Leaf x -> f x
+             | Node (l, r) -> Node ((tree_bind l f), (tree_bind r f));;
+```
+ +For once, let's check the Monad laws. The left identity law is easy: + + Left identity: bind (unit a) f = bind (Leaf a) f = fa + +To check the other two laws, we need to make the following +observation: it is easy to prove based on `tree_bind` by a simple +induction on the structure of the first argument that the tree +resulting from `bind u f` is a tree with the same strucure as `u`, +except that each leaf `a` has been replaced with `fa`: + +\tree (. (fa1) (. (. (. (fa2)(fa3)) (fa4)) (fa5))) +
```+                .                         .
+              __|__                     __|__
+              |   |                     |   |
+              a1  .                    fa1  .
+                 _|__                     __|__
+                 |  |                     |   |
+                 .  a5                    .  fa5
+   bind         _|__       f   =        __|__
+                |  |                    |   |
+                .  a4                   .  fa4
+              __|__                   __|___
+              |   |                   |    |
+              a2  a3                 fa2  fa3
+```
+ +Given this equivalence, the right identity law + + Right identity: bind u unit = u + +falls out once we realize that + + bind (Leaf a) unit = unit a = Leaf a + +As for the associative law, + + Associativity: bind (bind u f) g = bind u (\a. bind (fa) g) + +we'll give an example that will show how an inductive proof would +proceed. Let `f a = Node (Leaf a, Leaf a)`. Then + +\tree (. (. (. (. (a1)(a2))))) +\tree (. (. (. (. (a1) (a1)) (. (a1) (a1))) )) +
```+                                           .
+                                       ____|____
+          .               .            |       |
+bind    __|__   f  =    __|_    =      .       .
+        |   |           |   |        __|__   __|__
+        a1  a2         fa1 fa2       |   |   |   |
+                                     a1  a1  a1  a1
+```
+ +Now when we bind this tree to `g`, we get + +
```+           .
+       ____|____
+       |       |
+       .       .
+     __|__   __|__
+     |   |   |   |
+    ga1 ga1 ga1 ga1
+```
+ +At this point, it should be easy to convince yourself that +using the recipe on the right hand side of the associative law will +built the exact same final tree. + +So binary trees are a monad. + +Haskell combines this monad with the Option monad to provide a monad +called a +[SearchTree](http://hackage.haskell.org/packages/archive/tree-monad/0.2.1/doc/html/src/Control-Monad-SearchTree.html#SearchTree) +that is intended to +represent non-deterministic computations as a tree. + + +Refunctionalizing zippers: from lists to continuations +------------------------------------------------------ + +Let's work with lists of chars for a change. To maximize readability, we'll +indulge in an abbreviatory convention that "abc" abbreviates the +list `['a'; 'b'; 'c']`. + +Task 1: replace each occurrence of 'S' with a copy of the string up to +that point. + +Expected behavior: + +
```+t1 "abSe" ~~> "ababe"
+```
+ + +In linguistic terms, this is a kind of anaphora +resolution, where `'S'` is functioning like an anaphoric element, and +the preceding string portion is the antecedent. + +This deceptively simple task gives rise to some mind-bending complexity. +Note that it matters which 'S' you target first (the position of the * +indicates the targeted 'S'): + +
```+    t1 "aSbS"
+         *
+~~> t1 "aabS"
+           *
+~~> "aabaab"
+```
+ +versus + +
```+    t1 "aSbS"
+           *
+~~> t1 "aSbaSb"
+         *
+~~> t1 "aabaSb"
+            *
+~~> "aabaaabab"
+```
+ +versus + +
```+    t1 "aSbS"
+           *
+~~> t1 "aSbaSb"
+            *
+~~> t1 "aSbaaSbab"
+             *
+~~> t1 "aSbaaaSbaabab"
+              *
+~~> ...
+```
+ +Aparently, this task, as simple as it is, is a form of computation, +and the order in which the `'S'`s get evaluated can lead to divergent +behavior. + +For now, as usual, we'll agree to always evaluate the leftmost `'S'`. + +This is a task well-suited to using a zipper. + +
```+type 'a list_zipper = ('a list) * ('a list);;
+
+let rec t1 (z:char list_zipper) =
+    match z with (sofar, []) -> List.rev(sofar) (* Done! *)
+               | (sofar, 'S'::rest) -> t1 ((List.append sofar sofar), rest)
+               | (sofar, fst::rest) -> t1 (fst::sofar, rest);; (* Move zipper *)
+
+# t1 ([], ['a'; 'b'; 'S'; 'e']);;
+- : char list = ['a'; 'b'; 'a'; 'b'; 'e']
+
+# t1 ([], ['a'; 'S'; 'b'; 'S']);;
+- : char list = ['a'; 'a'; 'b'; 'a'; 'a'; 'b']
+```
+ +Note that this implementation enforces the evaluate-leftmost rule. +Task 1 completed. + +One way to see exactly what is going on is to watch the zipper in +action by tracing the execution of `t1`. By using the `#trace` +directive in the Ocaml interpreter, the system will print out the +arguments to `t1` each time it is (recurcively) called: + +
```+# #trace t1;;
+t1 is now traced.
+# t1 ([], ['a'; 'b'; 'S'; 'e']);;
+t1 <-- ([], ['a'; 'b'; 'S'; 'e'])
+t1 <-- (['a'], ['b'; 'S'; 'e'])
+t1 <-- (['b'; 'a'], ['S'; 'e'])
+t1 <-- (['b'; 'a'; 'b'; 'a'], ['e'])
+t1 <-- (['e'; 'b'; 'a'; 'b'; 'a'], [])
+t1 --> ['a'; 'b'; 'a'; 'b'; 'e']
+t1 --> ['a'; 'b'; 'a'; 'b'; 'e']
+t1 --> ['a'; 'b'; 'a'; 'b'; 'e']
+t1 --> ['a'; 'b'; 'a'; 'b'; 'e']
+t1 --> ['a'; 'b'; 'a'; 'b'; 'e']
+- : char list = ['a'; 'b'; 'a'; 'b'; 'e']
+```
+ +The nice thing about computations involving lists is that it's so easy +to visualize them as a data structure. Eventually, we want to get to +a place where we can talk about more abstract computations. In order +to get there, we'll first do the exact same thing we just did with +concrete zipper using procedures. + +Think of a list as a procedural recipe: `['a'; 'b'; 'c']` means (1) +start with the empty list `[]`; (2) make a new list whose first +element is 'c' and whose tail is the list construted in the previous +step; (3) make a new list whose first element is 'b' and whose tail is +the list constructed in the previous step; and (4) make a new list +whose first element is 'a' and whose tail is the list constructed in +the previous step. + +What is the type of each of these steps? Well, it will be a function +from the result of the previous step (a list) to a new list: it will +be a function of type `char list -> char list`. We'll call each step +a **continuation** of the recipe. So in this context, a continuation +is a function of type `char list -> char list`. + +This means that we can now represent the sofar part of our zipper--the +part we've already unzipped--as a continuation, a function describing +how to finish building the list: + +
```+let rec t1c (l: char list) (c: (char list) -> (char list)) =
+  match l with [] -> c []
+             | 'S'::rest -> t1c rest (fun x -> c (c x))
+             | a::rest -> t1c rest (fun x -> List.append (c x) [a]);;
+
+# t1c ['a'; 'b'; 'S'] (fun x -> x);;
+- : char list = ['a'; 'b'; 'a'; 'b']
+
+# t1c ['a'; 'S'; 'b'; 'S'] (fun x -> x);;
+- : char list = ['a'; 'a'; 'b'; 'a'; 'a'; 'b']
+```
+ +Note that we don't need to do any reversing.