added LaTeXMathML files
[lambda.git] / monad_library.mdwn
index 6c6a7a6..1761e61 100644 (file)
@@ -1,6 +1,6 @@
 We've written a full-featured [OCaml Monad Library](/code/monads.ml). To use it, download the file and then in your OCaml session or file, write:
 
-       #use "path/to/monads.ml";;
+       # #use "path/to/monads.ml";;
 
 That's not the official, preferred way to load OCaml libraries, but it's quick and easy.
 
@@ -10,7 +10,10 @@ Some comments on the design of this library.
 
 *      It gets tedious to write things like:
 
-               List_monad.bind (List_monad.unit 1) (fun a -> List_monad.plus (List_monad.unit a) (List_monad.unit (succ a)));;
+               List_monad.bind (List_monad.unit 1) (fun a ->
+                  List_monad.plus
+                    (List_monad.unit a)
+                    (List_monad.unit (succ a)));;
 
        So instead, we recommend the following shortcut:
 
@@ -43,11 +46,14 @@ Some comments on the design of this library.
 
                module S = State_monad(struct type store = int end);;
                S.unit 1;;
-               S.get;; (* this monadic value retrieves the current store *)
-               S.put 20;; (* installs 20 as the new store *)
-               S.puts succ;; (* applies succ to the current store, whatever it is *)
-               let u =
-                       S.(unit 1 >>= fun a -> put 20 >>= fun _ -> puts succ >>= fun _ -> get >>= fun b -> unit [a;b]);;
+               S.get;; (* this monadic value would retrieve the current store *)
+               S.put 20;; (* would install 20 as the new store *)
+               S.puts succ;; (* would apply succ to the current store, whatever it is *)
+               let u = S.(unit 1 >>= fun a ->
+                   put 20 >>= fun _ ->
+                   puts succ >>= fun _ ->
+                   get >>= fun b ->
+                   unit [a;b]);;
 
        The monadic value `u` we've defined here binds a series of operations to an initial `unit 1`. The effect of these operations is to save the wrapped 1 in variable `a`, discard the current store and install 20 in its place, increment the current store, retrieve the current store and make that the wrapped value, and finally deliver a `unit [a;b]` where `b` is the current wrapped value and `a` is the 1 we saved earlier.
 
@@ -61,8 +67,11 @@ Some comments on the design of this library.
 
        So we'd have:
 
-               let u =
-                       S.(unit 1 >>= fun a -> put 20 >> puts succ >> get >>= fun b -> unit [a;b]);;
+               let u = S.(unit 1 >>= fun a ->
+                   put 20 >>
+                   puts succ >>
+                   get >>= fun b ->
+                   unit [a;b]);;
 
        How can we supply an initial store and get this computation started? You do it like this:
 
@@ -72,7 +81,11 @@ Some comments on the design of this library.
 
        Our wrapped value at the end is `[1; 21]`, and the current store is `21`. Compare also:
 
-               # S.(run(let u = puts succ >> get in u >>= fun a1 -> u >>= fun a2 -> u >>= fun a3 -> unit [a1;a2;a3])) 0;;
+               # S.(run(let u = puts succ >> get in
+                       u >>= fun a1 ->
+                       u >>= fun a2 ->
+                       u >>= fun a3 ->
+                       unit [a1;a2;a3])) 0;;
                - : S.store list * S.store = ([1; 2; 3], 3)
                # S.(run(let u = puts succ >> get in sequence [u;u;u])) 0;;
                - : S.store list * S.store = ([1; 2; 3], 3)
@@ -137,6 +150,18 @@ Some comments on the design of this library.
        So the `run` operation lets you get from the hidden type to its actual implementation. What about the other way around? By design, there is no way to do this. You can't just hand the libary an arbitrary `store -> ('b * store)` and say it's an `('a,'b) S.m`. Instead, you should use the primitive operations in your `S` module---`unit`, `bind`, `get`, `puts` and so on---to build up the `('a,'b) S.m` you want.
 
 *      The same design is used in the `Ref_monad`. Keys into the store are implemented as `int`s, but their type is kept hidden (the computing community says "abstract"), so that the outside world can't do anything with the keys but
-compare them for equality and use them for derefs/and so on.
+compare them for equality and use them for derefs, and so on.
+
+
+Acknowledgements: Our library is largely based on the mtl library distributed with the Glasgow Haskell Compiler. That in turn was inspired by Mark Jones' 1995 paper
+[Functional Programming with Overloading and Higher-Order Polymorphism](http://web.cecs.pdx.edu/~mpj/pubs/springschool.html).
+ I've also been helped in
+ various ways by posts and direct feedback from Oleg Kiselyov and
+ Chung-chieh Shan. The following were also useful:
+
+ *     <http://pauillac.inria.fr/~xleroy/mpri/progfunc/>
+ *     Ken Shan "Monads for natural language semantics" <http://arxiv.org/abs/cs/0205026v1>
+ *     <http://www.grabmueller.de/martin/www/pub/Transformers.pdf>
+ *     <http://en.wikibooks.org/wiki/Haskell/Monad_transformers>