+++ /dev/null
-Here's the solution:
-
-
- let asker : char -> int Reader_custom.m =
- fun (a : char) -> fun (env : char -> int) -> env a;;
-
- let seed t = TR.monadize asker t;;
-
- let v3 = TreeCont.monadize (fun a k ->
- fun e -> k a (update_env e a)
- ) tree seed (fun a -> 0);;
-
-
-What's going on here? Our distributed function takes a leaf element `a`,
-a continuation `k` (which takes leaf elements and environments), and an
-environment `e`, and returns the result of passing the leaf element and
-an updated environment to `k`.
-
-As always, the seed function operates on trees of leaf elements where
-the distributed function operated on leaf elements. So the seed function
-takes a tree and a environment, and returns whatever you want.
-
-What we want is a tree-reader, that is, a function from environments to
-trees. Once this gets distributed over the tree using the
-`TreeCont.monadize` function, we'll have a tree-reader that operates on
-the updated environment instead of the initial environment (which we
-still have to supply---it's the final `fun a -> 0`).
-
-
-How can we build such a tree-reader? The same way we formerly turned a tree
-of `int`s and an int-to-b-reader function into a b-tree-reader: using the `TR.monadize` function.
-
-
-And `v3` is just what we were looking for:
-
- Node (Leaf 2, Node (Leaf 1, Node (Leaf 1, Leaf 2))).
-
-
-
-
-Now all of this should be implementable in the "monads.ml" library too. But as
-I said earlier, the encapsulation enforced by that library may make it somewhat harder to work with.
-
-
- module T = Tree_monad;;
- module C = Continuation_monad;;
- module S = State_monad(struct type store = char -> int end);;
- module R = Reader_monad(struct type env = char -> int end);;
- module TC = T.T(C);;
- module TS = T.T(S);;
- module TR = T.T(R);;
-
-
- # let v0 = TC.(run_exn (distribute (fun a ->
- C.(shift (fun k -> k a >>= fun v -> unit (1+v)))
- ) tree)) (fun a -> 0);;
- - : int = 5
-
-
- # let v1 = TC.(run_exn (distribute (fun a ->
- C.(shift (fun k -> k a >>= fun ka ->
- unit (fun e -> let e_prev = ka e in (update_env e_prev a))))
- ) tree)) (fun t e -> e) (fun a -> 0);;
- - : char -> int = <fun>
-
- (* now
- v1 '0';; ~~> 0
- v1 '1';; ~~> 2
- v1 '2';; ~~> 1
- *)
-
- # let v2 = TS.(run (distribute annotater tree)) (fun a -> 0);;
- # let (tree',env) = v2 in TR.(run (distribute (fun a -> a) tree')) env;;
-
- (* returns tree with leafs replaced with their numbers of occurrences *)
-
-
- # let v3 = TC.(run_exn (distribute (fun a ->
- C.(shift (fun k -> k a >>= fun ka ->
- unit (fun e -> ka (update_env e a))))
- ) tree)) (fun t ->
- TR.(run(distribute (fun a -> R.asks (fun e -> e a)) (Some t)))
- ) (fun a -> 0);;
-
- (* also returns tree with leafs replaced with their numbers of occurrences *)
-