edits

[lambda.git] / week7.mdwn

diff --git a/week7.mdwn b/week7.mdwn
index a78a77e..a4538ee 100644 (file)
--- a/week7.mdwn
+++ b/week7.mdwn
@@ -105,26 +105,26 @@ them from hurting the people that use them or themselves.
      object, we have `(unit x) * f == f x`.  For instance, `unit` is a
      function of type `'a -> 'a option`, so we have
 
-    <pre>
-    # let ( * ) m f = match m with None -> None | Some n -> f n;;
-    val ( * ) : 'a option -> ('a -> 'b option) -> 'b option = <fun>
-    # let unit x = Some x;;
-    val unit : 'a -> 'a option = <fun>
-    # unit 2 * unit;;
-    - : int option = Some 2
-    </pre>
-
-       The parentheses is the magic for telling Ocaml that the
-       function to be defined (in this case, the name of the function
-       is `*`, pronounced "bind") is an infix operator, so we write
-       `m * f` or `( * ) m f` instead of `* m f`.
+<pre>
+# let ( * ) m f = match m with None -> None | Some n -> f n;;
+val ( * ) : 'a option -> ('a -> 'b option) -> 'b option = <fun>
+# let unit x = Some x;;
+val unit : 'a -> 'a option = <fun>
+# unit 2 * unit;;
+- : int option = Some 2
+</pre>
+
+The parentheses is the magic for telling Ocaml that the
+function to be defined (in this case, the name of the function
+is `*`, pronounced "bind") is an infix operator, so we write
+`m * f` or `( * ) m f` instead of `* m f`.
 
 *    Associativity: bind obeys a kind of associativity, like this:
 
-    (m * f) * g == m * (fun x -> f x * g)
+    `(m * f) * g == m * (fun x -> f x * g)`
 
-    If you don't understand why the lambda form is necessary, you need
-    to look again at the type of bind.  This is important.  
+    If you don't understand why the lambda form is necessary (the "fun
+    x" part), you need to look again at the type of bind.
 
     For an illustration of associativity in the option monad:
 
@@ -135,15 +135,15 @@ Some 3 * (fun x -> unit x * unit);;
 - : int option = Some 3
 </pre>
 
-       Of course, associativity must hold for arbitrary functions of
-       type `'a -> M 'a`, where `M` is the monad type.  It's easy to
-       convince yourself that the bind operation for the option monad
-       obeys associativity by dividing the inputs into cases: if `m`
-       matches `None`, both computations will result in `None`; if
-       `m` matches `Some n`, and `f n` evalutes to `None`, then both
-       computations will again result in `None`; and if the value of
-       `f n` matches `Some r`, then both computations will evaluate
-       to `g r`.
+Of course, associativity must hold for arbitrary functions of
+type `'a -> M 'a`, where `M` is the monad type.  It's easy to
+convince yourself that the bind operation for the option monad
+obeys associativity by dividing the inputs into cases: if `m`
+matches `None`, both computations will result in `None`; if
+`m` matches `Some n`, and `f n` evalutes to `None`, then both
+computations will again result in `None`; and if the value of
+`f n` matches `Some r`, then both computations will evaluate
+to `g r`.
 
 *    Right identity: unit is a right identity for bind.  That is, 
      `m * unit == m` for all monad objects `m`.  For instance,