edits

[lambda.git] / week7.mdwn

diff --git a/week7.mdwn b/week7.mdwn
index 9f139c1..a78a77e 100644 (file)
--- a/week7.mdwn
+++ b/week7.mdwn
@@ -48,24 +48,24 @@ that provides at least the following three elements:
   use a container metaphor: if `x` has type `int option`, then `x` is
   a box that (may) contain an integer.
 
   use a container metaphor: if `x` has type `int option`, then `x` is
   a box that (may) contain an integer.
 

-    type 'a option = None | Some of 'a;;
+    `type 'a option = None | Some of 'a;;`

 
 * A way to turn an ordinary value into a monadic value.  In Ocaml, we
   did this for any integer n by mapping an arbitrary integer `n` to
   the option `Some n`.  To be official, we can define a function
   called unit:
 
 
 * A way to turn an ordinary value into a monadic value.  In Ocaml, we
   did this for any integer n by mapping an arbitrary integer `n` to
   the option `Some n`.  To be official, we can define a function
   called unit:
 

-    let unit x = Some x;;
-    val unit : 'a -> 'a option = <fun>
+    `let unit x = Some x;;`
+
+    `val unit : 'a -> 'a option = <fun>`

 
     So `unit` is a way to put something inside of a box.
 
 * A bind operation (note the type):
 
 
     So `unit` is a way to put something inside of a box.
 
 * A bind operation (note the type):
 

-<pre>
-     let bind m f = match m with None -> None | Some n -> f n;;
-     val bind : 'a option -> ('a -> 'b option) -> 'b option = <fun>
-</pre>
+     `let bind m f = match m with None -> None | Some n -> f n;;`
+
+     `val bind : 'a option -> ('a -> 'b option) -> 'b option = <fun>`

 
      `bind` takes two arguments (a monadic object and a function from
      ordinary objects to monadic objects), and returns a monadic
 
      `bind` takes two arguments (a monadic object and a function from
      ordinary objects to monadic objects), and returns a monadic


@@ -77,7 +77,7 @@ that provides at least the following three elements:
      Then the second argument uses `x` to compute a new monadic
      value.  Conceptually, then, we have
 
      Then the second argument uses `x` to compute a new monadic
      value.  Conceptually, then, we have
 

-    let bind m f = (let x = unwrap m in f x);;
+    `let bind m f = (let x = unwrap m in f x);;`

 
     The guts of the definition of the `bind` operation amount to
     specifying how to unwrap the monadic object `m`.  In the bind
 
     The guts of the definition of the `bind` operation amount to
     specifying how to unwrap the monadic object `m`.  In the bind


@@ -105,14 +105,14 @@ 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
 
      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>
+    <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
 
        The parentheses is the magic for telling Ocaml that the
        function to be defined (in this case, the name of the function