Okay, I tried to post this a couple of days ago, but it didn't seem to
work. Here's the five-minute Caml lesson.
First, function definition: function bindings are introduced with a
'let' construct:
let add a b c = a + b + c
To call a function, you do this:
add 3 5 7
- : int = 15
Note that there are no parentheses -- simple juxtaposition will
do. Like all functional languages, Caml supports nested and
first-class functions, and uses tail-recursion to do looping.
let fib n =
let rec loop i a b =
if i = 0 then
a
else
loop (i-1) b (a+b)
in
loop n 1 1
fib 6
- : int = 13
Now, since Caml is functional, by default variables are immutable, and
can't be mutated. As a result, if you want a mutable variable, you need
to use a reference:
let x = ref 3
val x : int ref = {contents=3}
!x (* Dereference x *)
- : int = 3
x := !x + 3 (* Increment the value inside x *)
!x
- : int = 6
Now we come to one of the annoying redundancies in Ocaml syntax. The
':=' notation is not the only way to write mutation. When you have
records with mutable fields, then you can use the '<-' notation for
mutation as well:
type foo = {mutable bar: int}
let x = {bar = 6}
x.bar
- : int = 6
x.bar <- x.bar - 3 (* The record field is mutated *)
x.bar
- : int = 3
Now, the quick and dirty object tutorial. Here's a simple class
class foo =
object
val mutable x = 0 (* A mutable instance variable *)
method get_x = x (* A getter for the instance var x *)
end
let obj = new foo
obj#get_x (* Method call uses '#' instead of '.' *)
You can add arguments to the initalizer like so:
class point u v =
object
val mutable x = u
val mutable y = v
method get_x = x
method get_y = y
method move dx dy =
begin
x <- x + dx;
y <- y + dy;
end
end
let pt = new point 3 5
pt#get_x
- : int = 3
pt#move 4 5
(pt#get_x, pt#get_y)
- : int * int = 7, 10
I've read the previously posted rant
