ass10 tweak
[lambda.git] / translating_between_OCaml_Scheme_and_Haskell.mdwn
index 2e33b1a..338a296 100644 (file)
@@ -385,7 +385,9 @@ We will however try to give some general advice about how to translate between O
 
 ##Records##
 
-Haskell and OCaml both have `records`, which are essentially just tuples with a pretty interface. The syntax for declaring and using these is a little bit different in the two languages.
+Haskell and OCaml both have `records`, which are essentially just tuples with a pretty interface. We introduced these in the wiki notes [here](/coroutines_and_aborts/).
+
+The syntax for declaring and using these is a little bit different in the two languages.
 
 *      In Haskell one says:
 
@@ -432,7 +434,7 @@ Haskell and OCaml both have `records`, which are essentially just tuples with a
 
        In OCaml:
 
-               let { red = r; green = g } = c
+               let { red = r; green = g; _ } = c
                in r
 
        In Haskell:
@@ -446,11 +448,37 @@ Haskell and OCaml both have `records`, which are essentially just tuples with a
 
        In OCaml it's:
 
-               # let makegray ({red = r} as c) = { c with green=r; blue=r };;
+               # let makegray ({ red = r; _ } as c) = { c with green=r; blue=r };;
                val makegray : color -> color = <fun>
                # makegray { red = 0; green = 127; blue = 255 };;
                - : color = {red = 0; green = 0; blue = 0}
 
+*      Records just give your types a pretty interface; they're entirely dispensable. Instead of:
+
+               type color = { red : int; green : int; blue : int };;
+               let c = { red = 0; green = 127; blue = 255 };;
+               let r = c.red;;
+
+       You could instead just use a more familiar data constructor:
+
+               type color = Color of (int * int * int);;
+               let c = Color (0, 127, 255);;
+       
+       and then extract the field you want using pattern-matching:
+
+               let Color (r, _, _) = c;;
+               (* or *)
+               match c with Color (r, _, _) -> ...
+
+       (Or you could just use bare tuples, without the `Color` data constructor.)
+
+       The record syntax only exists because programmers sometimes find it more convenient to say:
+
+               ... c.red ...
+
+       than to reach for those pattern-matching constructions.
+
+
 
 ##Functions##