Download here - The Caml language

50
# Oo.copy;;
- : (< .. > as ’a) -> ’a = <fun>
The keyword as in that type binds the type variable ’a to the object type < .. >. Therefore,
Oo.copy takes an object with any methods (represented by the ellipsis), and returns an object of
the same type. The type of Oo.copy is different from type < .. > -> < .. > as each ellipsis
represents a different set of methods. Ellipsis actually behaves as a type variable.
# let p = new point 5;;
val p : point = <obj>
# let q = Oo.copy p;;
val q : point = <obj>
# q#move 7; (p#get_x, q#get_x);;
- : int * int = 5, 12
In fact, Oo.copy p will behave as p#copy assuming that a public method copy with body {< >}
has been defined in the class of p.
Objects can be compared using the generic comparison functions = and <>. Two objects are
equal if and only if they are physically equal. In particular, an object and its copy are not equal.
# let q = Oo.copy p;;
val q : point = <obj>
# p = q, p = p;;
- : bool * bool = false, true
Other generic comparissons such as (<, <=,...) can also be used on objects. The relation < defines
an unspecified but strict ordering on objets. The ordering relationship between two objects is fixed
once for all after the two objects have been created and it is not affected by mutation of fields.
Cloning and override have a non empty intersection. They are interchangeable when used within
an object and without overriding any field:
# class copy =
#
object
#
method copy = {< >}
#
end;;
class copy : object (’a) method copy : ’a end
# class copy =
#
object (self)
#
method copy = Oo.copy self
#
end;;
class copy : object (’a) method copy : ’a end
Only the override can be used to actually override fields, and only the Oo.copy primitive can be
used externally.
Cloning can also be used to provide facilities for saving and restoring the state of objects.