It would be a simple matter to turn an *integer* into an `int reader`:
- let get_int : int -> int reader = fun (a : int) -> fun (modifier : int -> int) -> modifier a;;
- get_int 2 (fun i -> i + i);;
+ let int_getter : int -> int reader = fun (a : int) -> fun (modifier : int -> int) -> modifier a;;
+ int_getter 2 (fun i -> i + i);;
- : int = 4
But how do we do the analagous transformation when our `int`s are scattered over the leaves of a tree? How do we turn an `int tree` into a reader?
In more fanciful terms, the `tree_monadize` function builds plumbing that connects all of the leaves of a tree into one connected monadic network; it threads the
`'b reader` monad through the original tree's leaves.
- # tree_monadize t1 get_int double;;
+ # tree_monadize t1 int_getter double;;
- : 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, `tree_monadize
-t1 get_int`) to a different `int -> int` function---say, the
+t1 int_getter`) to a different `int -> int` function---say, the
squaring function, `fun i -> i * i`---we get an entirely different
result:
- # tree_monadize t1 get_int square;;
+ # tree_monadize t1 int_getter square;;
- : int tree =
Node (Node (Leaf 4, Leaf 9), Node (Leaf 25, Node (Leaf 49, Leaf 121)))