ass10 tweak
[lambda.git] / translating_between_OCaml_Scheme_and_Haskell.mdwn
index 300eb61..338a296 100644 (file)
@@ -111,6 +111,9 @@ Additionally, the syntax of OCaml and SML is superficially much closer to Haskel
        But assuming you do manage to compile and install Oleg's library, here's how you'd use it in an OCaml session:
 
                #require "delimcc";; (* loading Oleg's library this way requires the findlib package *)
+                   (* if you don't have findlib, you'll need to start ocaml like
+                    * this instead: ocaml -I /path/to/directory/containing/delimcc delimcc.cma
+                    *)
                open Delimcc;; (* this lets you say e.g. new_prompt instead of Delimcc.new_prompt *)
                let p = new_prompt ();;
                let prompt thunk = push_prompt p thunk;;
@@ -382,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:
 
@@ -429,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:
@@ -443,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##