index ff47d06..c8133e2 100644 (file)
@@ -151,31 +151,28 @@ When Option is on the inside, on the other hand, as in SO, failure means the who
Exception: Failure "bye".
-->

-<!--
Here's an example wrapping Option around List, and vice versa:

-        # let plus = ???;;
-       # OL.(run (plus mzero mid 20 >>= fun i -> mid (i+10)));;
+       # module OL = Monad.Option.P(Monad.List);; (* we use the `.P` transformer to hoist List's ++ operation *)
+       # OL.(run (mzero ++ mid 20 >>= fun x -> mid (x+10) ));;
- : int OL.result = [Some 30]

When List is on the inside, the failed results just got dropped and the computation proceeds without them.

-       # LO.(run ((++) (hoist Monad.Option.mzero) (mid 20) >>= fun i -> mid (i+10)));;
+       # LO.(run (hoist Monad.Option.mzero ++ mid 20 >>= fun x -> mid (x+10) ));;
- : int LO.result = None

-On the other hand, when Option is on the inside, as in LO, failures (which we represent by `mzero`s from the Option monad, here `hoist Monad.Option.mzero`, not the List monad's own `mzero`) abort the whole computation.
+On the other hand, when Option is on the inside, as in LO, failures (which we again represent by `mzero`s from the Option monad, not the List monad's own `mzero`; but here since it's the inner monad we need to `hoist Monad.Option.mzero`) abort the whole computation. (If you instead used the List monad's `mzero`, it'd be ignored by `++` and you'd end with just `Some `.)

-This is fun. Notice the difference it makes whether the second `++` is native to the outer `Monad.List`, or whether it's the inner `Monad.List`'s `++` hoisted into the outer wrapper:
+This is fun. Here is a List around a List. Notice the difference it makes whether the second `++` is native to the outer `Monad.List`, or whether it's the inner `Monad.List`'s `++` hoisted into the outer wrapper:

-       # LL.(run((++) (mid 1) (mid 2) >>= fun i -> (++) (mid i) (mid (10*i)) ));;
+       # LL.(run(mid 1 ++ mid 2 >>= fun x -> mid x ++ mid (10*x) ));;
- : int LL.result = \[[1; 10; 2; 20]]
-       # LL.(run((++) (mid 1) (mid 2) >>= fun i -> hoist L.((++) (mid i) (mid (10*i)) )));;
+       #  LL.(run(mid 1 ++ mid 2 >>= fun x -> hoist Monad.List.(mid x ++ mid (10*x)) ));;
- : int LL.result = [[1; 2]; [1; 20]; [10; 2]; [10; 20]]
--->

<!--
# EL.(run((++) (throw "bye") (mid 20) >>= fun i -> mid (i+10)));;
@@ -193,7 +190,8 @@ This is fun. Notice the difference it makes whether the second `++` is native to