From: Jim Pryor
Date: Sat, 4 Dec 2010 20:41:00 +0000 (0500)
Subject: Merge branch 'pryor'
XGitUrl: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=commitdiff_plain;h=9b2879707f4b21abeaff3dd4fc979a7d0cf211d5;hp=4e8e1f9f82123640aa1572f5ee79fa9df9f3af73
Merge branch 'pryor'

diff git a/manipulating_trees_with_monads.mdwn b/manipulating_trees_with_monads.mdwn
index ba990d10..52b8508c 100644
 a/manipulating_trees_with_monads.mdwn
+++ b/manipulating_trees_with_monads.mdwn
@@ 3,11 +3,13 @@
Manipulating trees with monads

This topic develops an idea based on a detailed suggestion of Ken
Shan's. We'll build a series of functions that operate on trees,
doing various things, including replacing leaves, counting nodes, and
converting a tree to a list of leaves. The end result will be an
application for continuations.
+This topic develops an idea based on a suggestion of Ken Shan's.
+We'll build a series of functions that operate on trees, doing various
+things, including updating leaves with a Reader monad, counting nodes
+with a State monad, replacing leaves with a List monad, and converting
+a tree into a list of leaves with a Continuation monad. It will turn
+out that the continuation monad can simulate the behavior of each of
+the other monads.
From an engineering standpoint, we'll build a tree transformer that
deals in monads. We can modify the behavior of the system by swapping
@@ 30,7 +32,7 @@ We'll be using trees where the nodes are integers, e.g.,
let t1 = Node (Node (Leaf 2, Leaf 3),
Node (Leaf 5, Node (Leaf 7,
 Leaf 11)))
+ Leaf 11)))
.
______
 
@@ 71,10 +73,11 @@ structure of the tree unchanged. For instance:
14 22
We could have built the doubling operation right into the `tree_map`
code. However, because we've left what to do to each leaf as a parameter, we can
decide to do something else to the leaves without needing to rewrite
`tree_map`. For instance, we can easily square each leaf instead by
supplying the appropriate `int > int` operation in place of `double`:
+code. However, because we've made what to do to each leaf a
+parameter, we can decide to do something else to the leaves without
+needing to rewrite `tree_map`. For instance, we can easily square
+each leaf instead by supplying the appropriate `int > int` operation
+in place of `double`:
let square i = i * i;;
tree_map square t1;;
@@ 106,14 +109,25 @@ updated tree.
f 7 f 11
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 `f` returns an `int
tree` in which each leaf `i` has been replaced with `f i`.

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
Jacobsoninspired link monad), etc. In the present case, we expect that our "environment" will be some function of type `int > int`. "Looking up" some `int` in the environment will return us the `int` that comes out the other side of that function.
+tree`) into a reader monadic object of type `(int > int) > int
+tree`: something that, when you apply it to an `int > int` function
+`f` returns an `int tree` in which each leaf `i` has been replaced
+with `f i`.
+
+[Application note: this kind of reader object could provide a model
+for Kaplan's characters. It turns an ordinary tree into one that
+expects contextual information (here, the `λ f`) that can be
+used to compute the content of indexicals embedded arbitrarily deeply
+in the tree.]
+
+With our previous applications of the Reader monad, we always knew
+which kind of environment to expect: either an assignment function, as
+in the original calculator simulation; a world, as in the
+intensionality monad; an individual, as in the Jacobsoninspired link
+monad; etc. In the present case, we expect that our "environment"
+will be some function of type `int > int`. "Looking up" some `int` in
+the environment will return us the `int` that comes out the other side
+of that function.
type 'a reader = (int > int) > 'a;; (* mnemonic: e for environment *)
let reader_unit (a : 'a) : 'a reader = fun _ > a;;
@@ 218,14 +232,21 @@ Then we can count the number of leaves in the tree:
______
 
. .
 ___ ___
+ ___ ___ , 5
   
2 3 5 .
___
 
7 11
Why does this work? Because the operation `fun a > fun s > (a, s+1)` takes an `int` and wraps it in an `int state` monadic box that increments the state. When we give that same operations to our `tree_monadize` function, it then wraps an `int tree` in a box, one that does the same stateincrementing for each of its leaves.
+Note that the value returned is a pair consisting of a tree and an
+integer, 5, which represents the count of the leaves in the tree.
+
+Why does this work? Because the operation `fun a > fun s > (a, s+1)`
+takes an `int` and wraps it in an `int state` monadic box that
+increments the state. When we give that same operations to our
+`tree_monadize` function, it then wraps an `int tree` in a box, one
+that does the same stateincrementing for each of its leaves.
One more revealing example before getting down to business: replacing
`state` everywhere in `tree_monadize` with `list` gives us
@@ 240,11 +261,11 @@ 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. We might also have done this with a Reader monad, though then our environments would need to be of type `int > int list`. Experiment with what happens if you supply the `tree_monadize` based on the List monad an operation like `fun > [ i; [2*i; 3*i] ]`. Use small trees for your experiment.



+[Why is the argument to tree_monadize `int > int list list` instead
+of `int > int list`? Well, as usual, the List monad bind operation
+will erase the outer list box, so if we want to replace the leaves
+with lists, we have to nest the replacement lists inside a disposable
+box.]
Now for the main point. What if we wanted to convert a tree to a list
of leaves?
@@ 311,7 +332,8 @@ The Binary Tree monad

Of course, by now you may have realized that we have discovered a new
monad, the Binary Tree monad:
+monad, the Binary Tree monad. Just as mere lists are in fact a monad,
+so are trees. Here is the type constructor, unit, and bind:
type 'a tree = Leaf of 'a  Node of ('a tree) * ('a tree);;
let tree_unit (a: 'a) : 'a tree = Leaf a;;