1839455a6542b7df4b9339222295d6f871b14358
1 [[!toc]]
3 Types, OCAML
4 ------------
6 OCAML has type inference: the system can often infer what the type of
7 an expression must be, based on the type of other known expressions.
9 For instance, if we type
11     # let f x = x + 3;;
13 The system replies with
15     val f : int -> int = <fun>
17 Since `+` is only defined on integers, it has type
19      # (+);;
20      - : int -> int -> int = <fun>
22 The parentheses are there to turn off the trick that allows the two
23 arguments of `+` to surround it in infix (for linguists, SOV) argument
24 order. That is,
26     # 3 + 4 = (+) 3 4;;
27     - : bool = true
29 In general, tuples with one element are identical to their one
30 element:
32     # (3) = 3;;
33     - : bool = true
35 though OCAML, like many systems, refuses to try to prove whether two
36 functional objects may be identical:
38     # (f) = f;;
39     Exception: Invalid_argument "equal: functional value".
41 Oh well.
44 Booleans in OCAML, and simple pattern matching
45 ----------------------------------------------
47 Where we would write `true 1 2` and expect it to evaluate to `1`, in
48 OCAML boolean types are not functions (equivalently, are functions
49 that take zero arguments).  Choices are made as follows:
51     # if true then 1 else 2;;
52     - : int = 1
54 The types of the `then` clause and of the `else` clause must be the
55 same.
57 The `if` construction can be re-expressed by means of the following
58 pattern-matching expression:
60     match <bool expression> with true -> <expression1> | false -> <expression2>
62 That is,
64     # match true with true -> 1 | false -> 2;;
65     - : int = 1
67 Compare with
69     # match 3 with 1 -> 1 | 2 -> 4 | 3 -> 9;;
70     - : int = 9
72 Unit
73 ----
75 All functions in OCAML take exactly one argument.  Even this one:
77     # let f x y = x + y;;
78     # f 2 3;;
79     - : int = 5
81 Here's how to tell that `f` has been curry'd:
83     # f 2;;
84     - : int -> int = <fun>
86 After we've given our `f` one argument, it returns a function that is
87 still waiting for another argument.
89 There is a special type in OCAML called `unit`.  There is exactly one
90 object in this type, written `()`.  So
92     # ();;
93     - : unit = ()
95 Just as you can define functions that take constants for arguments
97     # let f 2 = 3;;
98     # f 2;;
99     - : int = 3;;
101 you can also define functions that take the unit as its argument, thus
103     # let f () = 3;;
104     val f : unit -> int = <fun>
106 Then the only argument you can possibly apply `f` to that is of the
107 correct type is the unit:
109     # f ();;
110     - : int = 3
112 Let's have some fn: think of `rec` as our `Y` combinator.  Then
114     # let rec f n = if (0 = n) then 1 else (n * (f (n - 1)));;
115     val f : int -> int = <fun>
116     # f 5;;
117     - : int = 120
119 We can't define a function that is exactly analogous to our &omega;.
120 We could try `let rec omega x = x x;;` what happens?  However, we can
121 do this:
123     # let rec omega x = omega x;;
125 By the way, what's the type of this function?
126 If you then apply this omega to an argument,
128     # omega 3;;
130 the interpreter goes into an infinite loop, and you have to control-C
131 to break the loop.
133 Oh, one more thing: lambda expressions look like this:
135     # (fun x -> x);;
136     - : 'a -> 'a = <fun>
137     # (fun x -> x) true;;
138     - : book = true
140 (But `(fun x -> x x)` still won't work.)
142 So we can try our usual tricks:
144     # (fun x -> true) omega;;
145     - : bool = true
147 OCAML declined to try to evaluate the argument before applying the
148 functor.  But remember that `omega` is a function too, so we can
149 reverse the order of the arguments:
151     # omega (fun x -> true);;
153 Infinite loop.
155 Now consider the following differences:
157     # let test = omega omega;;
158     [Infinite loop, need to control c out]
160     # let test () = omega omega;;
161     val test : unit -> 'a = <fun>
163     # test;;
164     - : unit -> 'a = <fun>
166     # test ();;
167     [Infinite loop, need to control c out]
169 We can use functions that take arguments of type unit to control
170 execution.  In Scheme parlance, functions on the unit type are called
171 *thunks* (which I've always assumed was a blend of "think" and "chunk").