end;;
-(* Now we supply the Reader monad as a parameter to Tree_monadizer.
+(* Now we supply Reader_monad as a parameter to Tree_monadizer.
* We'll get back a module TreeReader that contains a single value,
* the monadize function specialized to the Reader monad *)
module TreeReader = Tree_monadizer(Reader_monad);;
*)
-let get_int : int -> int Reader_monad.monad =
+let int_getter : int -> int Reader_monad.monad =
fun (a : int) -> fun (env : int -> int) -> env a;;
-(* get_int takes an int and returns a Reader monad that
+(* int_getter takes an int and returns a Reader monad that
* "looks up" that int in the environment (i.e. modifies it)
* this is structurally parallel to the function `lookup` we used
* before to "look up" variables in the environment *)
(* double each leaf *)
let env = fun i -> i + i in
-TreeReader.monadize t1 get_int env;;
+TreeReader.monadize t1 int_getter env;;
(* You can also avoid declaring a separate toplevel TreeReader module
* (or even a separate Reader_monad module) by using one of these forms:
* ...
* let module T = Tree_monadizer(Reader_monad) in
- * T.monadize t1 get_int env;;
+ * T.monadize t1 int_getter env;;
* or:
* ...
* let env = fun i -> i + i in
* fun e -> f (u e) e;;
* end in
* let module T = Tree_monadizer(Monad) in
- * T.monadize t1 get_int env;;
+ * T.monadize t1 int_getter env;;
* or:
* ...
* let module T = Tree_monadizer(struct
* let bind (u : 'a m) (f : 'a -> 'b m) : 'b m =
* fun e -> f (u e) e;;
* end) in
- * T.monadize t1 get_int env;;
+ * T.monadize t1 int_getter env;;
*)
(* square each leaf *)
let env = fun i -> i * i in
-TreeReader.monadize t1 get_int env;;
+TreeReader.monadize t1 int_getter env;;
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)))