class oned_point xarg = 
  object
    val mutable x = xarg
\t
    method get_x = x
    method set_x d = x <- x + d
  end

class twod_point xarg yarg =
  object
    val mutable x = xarg
    val mutable y = yarg
\t
    method get_x = x
    method set_x d = x <- x + d
    method get_y = y
    method set_y d = y <- y + d
  end

let distance_from_x_axis obj = abs(obj#get_x)
inferred type:  < get_x : float; .. > -> float 

let manhattan obj = abs(obj#get_x) + abs(obj#get_y)
inferred type: < get_x : int; get_y : int; .. > -> int = <fun>

# let o1 = new oned_point 9;;
val o1 : oned_point = <obj>

# let o2 = new twod_point 3 9;;
val o2 : twod_point = <obj>

# distance_from_x_axis o1;;
- : int = 9

# distance_from_x_axis o2;;
- : int = 3

# manhattan o2;;
- : int = 12

# manhattan o1;;
Characters 10-12:
This expression has type oned_point = < get_x : int; set_x : int -> unit >
but is here used with type < get_x : int; get_y : int; .. >
Only the second object type has a method get_y

let add a b c = a + b + c

add 3 5 7
- : int = 15

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

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

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

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 '.' *)

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