pattern matching: use standard OCaml conventions

Signed-off-by: Jim Pryor <profjim@jimpryor.net>

diff --git a/towards_monads.mdwn b/towards_monads.mdwn
index 223c592..3671d27 100644 (file)
--- a/towards_monads.mdwn
+++ b/towards_monads.mdwn
@@ -1,7 +1,7 @@
 Dividing by zero
 ----------------
 
 Dividing by zero
 ----------------
 

-Integer division operation presupposes that its second argument
+Integer division presupposes that its second argument

 (the divisor) is not zero, upon pain of presupposition failure.
 Here's what my OCaml interpreter says:
 
 (the divisor) is not zero, upon pain of presupposition failure.
 Here's what my OCaml interpreter says:
 


@@ -10,7 +10,7 @@ Here's what my OCaml interpreter says:
 
 So we want to explicitly allow for the possibility that
 division will return something other than a number.
 
 So we want to explicitly allow for the possibility that
 division will return something other than a number.

-We'll use OCaml's option type, which works like this:
+We'll use OCaml's `option` type, which works like this:

 
     # type 'a option = None | Some of 'a;;
     # None;;
 
     # type 'a option = None | Some of 'a;;
     # None;;


@@ -19,12 +19,13 @@ We'll use OCaml's option type, which works like this:
     - : int option = Some 3
 
 So if a division is normal, we return some number, but if the divisor is
     - : int option = Some 3
 
 So if a division is normal, we return some number, but if the divisor is

-zero, we return None. As a mnemonic aid, we'll append a `'` to the end of our new divide function.
+zero, we return `None`. As a mnemonic aid, we'll append a `'` to the end of our new divide function.

 
 <pre>
 let div' (x:int) (y:int) =
 
 <pre>
 let div' (x:int) (y:int) =

-  match y with 0 -> None |
-               _ -> Some (x / y);;
+  match y with
+         0 -> None
+    | _ -> Some (x / y);;

 
 (*
 val div' : int -> int -> int option = fun
 
 (*
 val div' : int -> int -> int option = fun


@@ -48,10 +49,12 @@ operations.  So we have to jack up the types of the inputs:
 
 <pre>
 let div' (x:int option) (y:int option) =
 
 <pre>
 let div' (x:int option) (y:int option) =

-  match y with None -> None |
-               Some 0 -> None |
-               Some n -> (match x with None -> None |
-                                       Some m -> Some (m / n));;
+  match y with
+         None -> None
+    | Some 0 -> None
+       | Some n -> (match x with
+                                         None -> None
+                    | Some m -> Some (m / n));;

 
 (*
 val div' : int option -> int option -> int option = <fun>
 
 (*
 val div' : int option -> int option -> int option = <fun>


@@ -72,10 +75,11 @@ built-in tuple type:
 
 <pre>
 let div' (x:int option) (y:int option) =
 
 <pre>
 let div' (x:int option) (y:int option) =

-  match (x, y) with (None, _) -> None |
-                    (_, None) -> None |
-                    (_, Some 0) -> None |
-                    (Some m, Some n) -> Some (m / n);;
+  match (x, y) with
+         (None, _) -> None
+    | (_, None) -> None
+    | (_, Some 0) -> None
+       | (Some m, Some n) -> Some (m / n);;

 </pre>
 
 So far so good.  But what if we want to combine division with
 </pre>
 
 So far so good.  But what if we want to combine division with


@@ -85,9 +89,10 @@ presupposition failure:
 
 <pre>
 let add' (x:int option) (y:int option) =
 
 <pre>
 let add' (x:int option) (y:int option) =

-  match (x, y) with (None, _) -> None |
-                    (_, None) -> None |
-                    (Some m, Some n) -> Some (m + n);;
+  match (x, y) with
+         (None, _) -> None
+    | (_, None) -> None
+    | (Some m, Some n) -> Some (m + n);;

 
 (*
 val add' : int option -> int option -> int option = <fun>
 
 (*
 val add' : int option -> int option -> int option = <fun>


@@ -108,8 +113,9 @@ well chosen to resonate with linguists, but what can you do). To continue our mn
 
 <pre>
 let bind' (x: int option) (f: int -> (int option)) =
 
 <pre>
 let bind' (x: int option) (f: int -> (int option)) =

-  match x with None -> None |
-               Some n -> f n;;
+  match x with
+         None -> None
+    | Some n -> f n;;

 
 let add' (x: int option) (y: int option)  =
   bind' x (fun x -> bind' y (fun y -> Some (x + y)));;
 
 let add' (x: int option) (y: int option)  =
   bind' x (fun x -> bind' y (fun y -> Some (x + y)));;