<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <meta name="generator" content="hevea 2.00"> <link rel="stylesheet" type="text/css" href="manual.css"> <title>Objects in OCaml</title> </head> <body> <a href="moduleexamples.html"><img src="previous_motif.gif" alt="Previous"></a> <a href="index.html"><img src="contents_motif.gif" alt="Up"></a> <a href="lablexamples.html"><img src="next_motif.gif" alt="Next"></a> <hr> <h1 class="chapter" id="sec23">Chapter 3  Objects in OCaml</h1> <ul> <li><a href="objectexamples.html#sec24">Classes and objects</a> </li><li><a href="objectexamples.html#sec25">Immediate objects</a> </li><li><a href="objectexamples.html#sec26">Reference to self</a> </li><li><a href="objectexamples.html#sec27">Initializers</a> </li><li><a href="objectexamples.html#sec28">Virtual methods</a> </li><li><a href="objectexamples.html#sec29">Private methods</a> </li><li><a href="objectexamples.html#sec30">Class interfaces</a> </li><li><a href="objectexamples.html#sec31">Inheritance</a> </li><li><a href="objectexamples.html#sec32">Multiple inheritance</a> </li><li><a href="objectexamples.html#sec33">Parameterized classes</a> </li><li><a href="objectexamples.html#sec34">Polymorphic methods</a> </li><li><a href="objectexamples.html#sec35">Using coercions</a> </li><li><a href="objectexamples.html#sec36">Functional objects</a> </li><li><a href="objectexamples.html#sec37">Cloning objects</a> </li><li><a href="objectexamples.html#sec38">Recursive classes</a> </li><li><a href="objectexamples.html#sec39">Binary methods</a> </li><li><a href="objectexamples.html#sec40">Friends</a> </li></ul> <p> <a id="c:objectexamples"></a> </p><p> <span class="c013">(Chapter written by Jérôme Vouillon, Didier Rémy and Jacques Garrigue)</span></p><p><br> <br> </p><p>This chapter gives an overview of the object-oriented features of OCaml. Note that the relation between object, class and type in OCaml is very different from that in mainstream object-oriented languages like Java or C++, so that you should not assume that similar keywords mean the same thing.</p><p><a href="#ss%3Aclasses-and-objects">3.1</a> Classes and objects <br> <a href="#ss%3Aimmediate-objects">3.2</a> Immediate objects <br> <a href="#ss%3Areference-to-self">3.3</a> Reference to self <br> <a href="#ss%3Ainitializers">3.4</a> Initializers <br> <a href="#ss%3Avirtual-methods">3.5</a> Virtual methods <br> <a href="#ss%3Aprivate-methods">3.6</a> Private methods <br> <a href="#ss%3Aclass-interfaces">3.7</a> Class interfaces <br> <a href="#ss%3Ainheritance">3.8</a> Inheritance <br> <a href="#ss%3Amultiple-inheritance">3.9</a> Multiple inheritance <br> <a href="#ss%3Aparameterized-classes">3.10</a> Parameterized classes <br> <a href="#ss%3Apolymorphic-methods">3.11</a> Polymorphic methods <br> <a href="#ss%3Ausing-coercions">3.12</a> Using coercions <br> <a href="#ss%3Afunctional-objects">3.13</a> Functional objects <br> <a href="#ss%3Acloning-objects">3.14</a> Cloning objects <br> <a href="#ss%3Arecursive-classes">3.15</a> Recursive classes <br> <a href="#ss%3Abinary-methods">3.16</a> Binary methods <br> <a href="#ss%3Afriends">3.17</a> Friends <br> </p> <h2 class="section" id="sec24">3.1  Classes and objects</h2> <p> <a id="ss:classes-and-objects"></a></p><p>The class <span class="c007">point</span> below defines one instance variable <span class="c007">x</span> and two methods <span class="c007">get_x</span> and <span class="c007">move</span>. The initial value of the instance variable is <span class="c007">0</span>. The variable <span class="c007">x</span> is declared mutable, so the method <span class="c007">move</span> can change its value. </p><pre><span class="c004">#<span class="c003"> class point = object val mutable x = 0 method get_x = x method move d = x <- x + d end;; <span class="c006">class point : object val mutable x : int method get_x : int method move : int -> unit end </span></span></span></pre><p>We now create a new point <span class="c007">p</span>, instance of the <span class="c007">point</span> class. </p><pre><span class="c004">#<span class="c003"> let p = new point;; <span class="c006">val p : point = <obj> </span></span></span></pre><p> Note that the type of <span class="c007">p</span> is <span class="c007">point</span>. This is an abbreviation automatically defined by the class definition above. It stands for the object type <span class="c007"><get_x : int; move : int -> unit></span>, listing the methods of class <span class="c007">point</span> along with their types.</p><p>We now invoke some methods to <span class="c007">p</span>: </p><pre><span class="c004">#</span><span class="c003"> p#get_x;; <span class="c006">- : int = 0 </span><span class="c004">#</span> p#move 3;; <span class="c006">- : unit = () </span><span class="c004">#</span> p#get_x;; </span><span class="c006">- : int = 3 </span></pre><p>The evaluation of the body of a class only takes place at object creation time. Therefore, in the following example, the instance variable <span class="c007">x</span> is initialized to different values for two different objects. </p><pre><span class="c004">#</span><span class="c003"> let x0 = ref 0;; <span class="c006">val x0 : int ref = {contents = 0} </span><span class="c004">#</span> class point = object val mutable x = incr x0; !x0 method get_x = x method move d = x <- x + d end;; <span class="c006">class point : object val mutable x : int method get_x : int method move : int -> unit end </span><span class="c004">#</span> new point#get_x;; <span class="c006">- : int = 1 </span><span class="c004">#</span> new point#get_x;; </span><span class="c006">- : int = 2 </span></pre><p>The class <span class="c007">point</span> can also be abstracted over the initial values of the <span class="c007">x</span> coordinate. </p><pre><span class="c004">#<span class="c003"> class point = fun x_init -> object val mutable x = x_init method get_x = x method move d = x <- x + d end;; <span class="c006">class point : int -> object val mutable x : int method get_x : int method move : int -> unit end </span></span></span></pre><p> Like in function definitions, the definition above can be abbreviated as: </p><pre><span class="c004">#<span class="c003"> class point x_init = object val mutable x = x_init method get_x = x method move d = x <- x + d end;; <span class="c006">class point : int -> object val mutable x : int method get_x : int method move : int -> unit end </span></span></span></pre><p> An instance of the class <span class="c007">point</span> is now a function that expects an initial parameter to create a point object: </p><pre><span class="c004">#</span><span class="c003"> new point;; <span class="c006">- : int -> point = <fun> </span><span class="c004">#</span> let p = new point 7;; </span><span class="c006">val p : point = <obj> </span></pre><p> The parameter <span class="c007">x_init</span> is, of course, visible in the whole body of the definition, including methods. For instance, the method <span class="c007">get_offset</span> in the class below returns the position of the object relative to its initial position. </p><pre><span class="c004">#<span class="c003"> class point x_init = object val mutable x = x_init method get_x = x method get_offset = x - x_init method move d = x <- x + d end;; <span class="c006">class point : int -> object val mutable x : int method get_offset : int method get_x : int method move : int -> unit end </span></span></span></pre><p> Expressions can be evaluated and bound before defining the object body of the class. This is useful to enforce invariants. For instance, points can be automatically adjusted to the nearest point on a grid, as follows: </p><pre><span class="c004">#<span class="c003"> class adjusted_point x_init = let origin = (x_init / 10) * 10 in object val mutable x = origin method get_x = x method get_offset = x - origin method move d = x <- x + d end;; <span class="c006">class adjusted_point : int -> object val mutable x : int method get_offset : int method get_x : int method move : int -> unit end </span></span></span></pre><p> (One could also raise an exception if the <span class="c007">x_init</span> coordinate is not on the grid.) In fact, the same effect could here be obtained by calling the definition of class <span class="c007">point</span> with the value of the <span class="c007">origin</span>. </p><pre><span class="c004">#<span class="c003"> class adjusted_point x_init = point ((x_init / 10) * 10);; <span class="c006">class adjusted_point : int -> point </span></span></span></pre><p> An alternate solution would have been to define the adjustment in a special allocation function: </p><pre><span class="c004">#<span class="c003"> let new_adjusted_point x_init = new point ((x_init / 10) * 10);; <span class="c006">val new_adjusted_point : int -> point = <fun> </span></span></span></pre><p> However, the former pattern is generally more appropriate, since the code for adjustment is part of the definition of the class and will be inherited.</p><p>This ability provides class constructors as can be found in other languages. Several constructors can be defined this way to build objects of the same class but with different initialization patterns; an alternative is to use initializers, as decribed below in section <a href="#ss%3Ainitializers">3.4</a>.</p> <h2 class="section" id="sec25">3.2  Immediate objects</h2> <p> <a id="ss:immediate-objects"></a></p><p>There is another, more direct way to create an object: create it without going through a class.</p><p>The syntax is exactly the same as for class expressions, but the result is a single object rather than a class. All the constructs described in the rest of this section also apply to immediate objects. </p><pre><span class="c004">#</span><span class="c003"> let p = object val mutable x = 0 method get_x = x method move d = x <- x + d end;; <span class="c006">val p : < get_x : int; move : int -> unit > = <obj> </span><span class="c004">#</span> p#get_x;; <span class="c006">- : int = 0 </span><span class="c004">#</span> p#move 3;; <span class="c006">- : unit = () </span><span class="c004">#</span> p#get_x;; </span><span class="c006">- : int = 3 </span></pre><p>Unlike classes, which cannot be defined inside an expression, immediate objects can appear anywhere, using variables from their environment. </p><pre><span class="c004">#<span class="c003"> let minmax x y = if x < y then object method min = x method max = y end else object method min = y method max = x end;; <span class="c006">val minmax : 'a -> 'a -> < max : 'a; min : 'a > = <fun> </span></span></span></pre><p>Immediate objects have two weaknesses compared to classes: their types are not abbreviated, and you cannot inherit from them. But these two weaknesses can be advantages in some situations, as we will see in sections <a href="#ss%3Areference-to-self">3.3</a> and <a href="#ss%3Aparameterized-classes">3.10</a>.</p> <h2 class="section" id="sec26">3.3  Reference to self</h2> <p> <a id="ss:reference-to-self"></a></p><p>A method or an initializer can send messages to self (that is, the current object). For that, self must be explicitly bound, here to the variable <span class="c007">s</span> (<span class="c007">s</span> could be any identifier, even though we will often choose the name <span class="c007">self</span>.) </p><pre><span class="c004">#</span><span class="c003"> class printable_point x_init = object (s) val mutable x = x_init method get_x = x method move d = x <- x + d method print = print_int s#get_x end;; <span class="c006">class printable_point : int -> object val mutable x : int method get_x : int method move : int -> unit method print : unit end </span><span class="c004">#</span> let p = new printable_point 7;; <span class="c006">val p : printable_point = <obj> </span><span class="c004">#</span> p#print;; </span><span class="c006">7- : unit = () </span></pre><p> Dynamically, the variable <span class="c007">s</span> is bound at the invocation of a method. In particular, when the class <span class="c007">printable_point</span> is inherited, the variable <span class="c007">s</span> will be correctly bound to the object of the subclass.</p><p>A common problem with self is that, as its type may be extended in subclasses, you cannot fix it in advance. Here is a simple example. </p><pre><span class="c004">#</span><span class="c003"> let ints = ref [];; <span class="c006">val ints : '_a list ref = {contents = []} </span><span class="c004">#</span> class my_int = object (self) method n = 1 method register = ints := <U>self</U> :: !ints end;; </span><span class="c006">Error: This expression has type < n : int; register : 'b; .. > as 'a but an expression was expected of type 'a This instance of < n : int; register : 'b; .. > is ambiguous: it would escape the scope of its equation </span></pre><p> You can ignore the first two lines of the error message. What matters is the last one: putting self into an external reference would make it impossible to extend it through inheritance. We will see in section <a href="#ss%3Ausing-coercions">3.12</a> a workaround to this problem. Note however that, since immediate objects are not extensible, the problem does not occur with them. </p><pre><span class="c004">#<span class="c003"> let my_int = object (self) method n = 1 method register = ints := self :: !ints end;; <span class="c006">val my_int : < n : int; register : unit > = <obj> </span></span></span></pre> <h2 class="section" id="sec27">3.4  Initializers</h2> <p> <a id="ss:initializers"></a></p><p>Let-bindings within class definitions are evaluated before the object is constructed. It is also possible to evaluate an expression immediately after the object has been built. Such code is written as an anonymous hidden method called an initializer. Therefore, it can access self and the instance variables. </p><pre><span class="c004">#</span><span class="c003"> class printable_point x_init = let origin = (x_init / 10) * 10 in object (self) val mutable x = origin method get_x = x method move d = x <- x + d method print = print_int self#get_x initializer print_string "new point at "; self#print; print_newline() end;; <span class="c006">class printable_point : int -> object val mutable x : int method get_x : int method move : int -> unit method print : unit end </span><span class="c004">#</span> let p = new printable_point 17;; </span><span class="c006">new point at 10 val p : printable_point = <obj> </span></pre><p> Initializers cannot be overridden. On the contrary, all initializers are evaluated sequentially. Initializers are particularly useful to enforce invariants. Another example can be seen in section <a href="advexamples.html#ss%3Abank-accounts">5.1</a>.</p> <h2 class="section" id="sec28">3.5  Virtual methods</h2> <p> <a id="ss:virtual-methods"></a></p><p>It is possible to declare a method without actually defining it, using the keyword <span class="c007">virtual</span>. This method will be provided later in subclasses. A class containing virtual methods must be flagged <span class="c007">virtual</span>, and cannot be instantiated (that is, no object of this class can be created). It still defines type abbreviations (treating virtual methods as other methods.) </p><pre><span class="c004">#</span><span class="c003"> class virtual abstract_point x_init = object (self) method virtual get_x : int method get_offset = self#get_x - x_init method virtual move : int -> unit end;; <span class="c006">class virtual abstract_point : int -> object method get_offset : int method virtual get_x : int method virtual move : int -> unit end </span><span class="c004">#</span> class point x_init = object inherit abstract_point x_init val mutable x = x_init method get_x = x method move d = x <- x + d end;; </span><span class="c006">class point : int -> object val mutable x : int method get_offset : int method get_x : int method move : int -> unit end </span></pre><p>Instance variables can also be declared as virtual, with the same effect as with methods. </p><pre><span class="c004">#</span><span class="c003"> class virtual abstract_point2 = object val mutable virtual x : int method move d = x <- x + d end;; <span class="c006">class virtual abstract_point2 : object val mutable virtual x : int method move : int -> unit end </span><span class="c004">#</span> class point2 x_init = object inherit abstract_point2 val mutable x = x_init method get_offset = x - x_init end;; </span><span class="c006">class point2 : int -> object val mutable x : int method get_offset : int method move : int -> unit end </span></pre> <h2 class="section" id="sec29">3.6  Private methods</h2> <p> <a id="ss:private-methods"></a></p><p>Private methods are methods that do not appear in object interfaces. They can only be invoked from other methods of the same object. </p><pre><span class="c004">#</span><span class="c003"> class restricted_point x_init = object (self) val mutable x = x_init method get_x = x method private move d = x <- x + d method bump = self#move 1 end;; <span class="c006">class restricted_point : int -> object val mutable x : int method bump : unit method get_x : int method private move : int -> unit end </span><span class="c004">#</span> let p = new restricted_point 0;; <span class="c006">val p : restricted_point = <obj> </span><span class="c004">#</span> <U>p</U>#move 10;; <span class="c006">Error: This expression has type restricted_point It has no method move </span><span class="c004">#</span> p#bump;; </span><span class="c006">- : unit = () </span></pre><p> Note that this is not the same thing as private and protected methods in Java or C++, which can be called from other objects of the same class. This is a direct consequence of the independence between types and classes in OCaml: two unrelated classes may produce objects of the same type, and there is no way at the type level to ensure that an object comes from a specific class. However a possible encoding of friend methods is given in section <a href="#ss%3Afriends">3.17</a>.</p><p>Private methods are inherited (they are by default visible in subclasses), unless they are hidden by signature matching, as described below.</p><p>Private methods can be made public in a subclass. </p><pre><span class="c004">#<span class="c003"> class point_again x = object (self) inherit restricted_point x method virtual move : _ end;; <span class="c006">class point_again : int -> object val mutable x : int method bump : unit method get_x : int method move : int -> unit end </span></span></span></pre><p> The annotation <span class="c007">virtual</span> here is only used to mention a method without providing its definition. Since we didn’t add the <span class="c007">private</span> annotation, this makes the method public, keeping the original definition.</p><p>An alternative definition is </p><pre><span class="c004">#<span class="c003"> class point_again x = object (self : < move : _; ..> ) inherit restricted_point x end;; <span class="c006">class point_again : int -> object val mutable x : int method bump : unit method get_x : int method move : int -> unit end </span></span></span></pre><p> The constraint on self’s type is requiring a public <span class="c007">move</span> method, and this is sufficient to override <span class="c007">private</span>.</p><p>One could think that a private method should remain private in a subclass. However, since the method is visible in a subclass, it is always possible to pick its code and define a method of the same name that runs that code, so yet another (heavier) solution would be: </p><pre><span class="c004">#<span class="c003"> class point_again x = object inherit restricted_point x as super method move = super#move end;; <span class="c006">class point_again : int -> object val mutable x : int method bump : unit method get_x : int method move : int -> unit end </span></span></span></pre><p>Of course, private methods can also be virtual. Then, the keywords must appear in this order <span class="c007">method private virtual</span>.</p> <h2 class="section" id="sec30">3.7  Class interfaces</h2> <p> <a id="ss:class-interfaces"></a></p><p>Class interfaces are inferred from class definitions. They may also be defined directly and used to restrict the type of a class. Like class declarations, they also define a new type abbreviation. </p><pre><span class="c004">#</span><span class="c003"> class type restricted_point_type = object method get_x : int method bump : unit end;; <span class="c006">class type restricted_point_type = object method bump : unit method get_x : int end </span><span class="c004">#</span> fun (x : restricted_point_type) -> x;; </span><span class="c006">- : restricted_point_type -> restricted_point_type = <fun> </span></pre><p> In addition to program documentation, class interfaces can be used to constrain the type of a class. Both concrete instance variables and concrete private methods can be hidden by a class type constraint. Public methods and virtual members, however, cannot. </p><pre><span class="c004">#<span class="c003"> class restricted_point' x = (restricted_point x : restricted_point_type);; <span class="c006">class restricted_point' : int -> restricted_point_type </span></span></span></pre><p> Or, equivalently: </p><pre><span class="c004">#<span class="c003"> class restricted_point' = (restricted_point : int -> restricted_point_type);; <span class="c006">class restricted_point' : int -> restricted_point_type </span></span></span></pre><p> The interface of a class can also be specified in a module signature, and used to restrict the inferred signature of a module. </p><pre><span class="c004">#</span><span class="c003"> module type POINT = sig class restricted_point' : int -> object method get_x : int method bump : unit end end;; <span class="c006">module type POINT = sig class restricted_point' : int -> object method bump : unit method get_x : int end end </span><span class="c004">#</span> module Point : POINT = struct class restricted_point' = restricted_point end;; </span><span class="c006">module Point : POINT </span></pre> <h2 class="section" id="sec31">3.8  Inheritance</h2> <p> <a id="ss:inheritance"></a></p><p>We illustrate inheritance by defining a class of colored points that inherits from the class of points. This class has all instance variables and all methods of class <span class="c007">point</span>, plus a new instance variable <span class="c007">c</span> and a new method <span class="c007">color</span>. </p><pre><span class="c004">#</span><span class="c003"> class colored_point x (c : string) = object inherit point x val c = c method color = c end;; <span class="c006">class colored_point : int -> string -> object val c : string val mutable x : int method color : string method get_offset : int method get_x : int method move : int -> unit end </span><span class="c004">#</span> let p' = new colored_point 5 "red";; <span class="c006">val p' : colored_point = <obj> </span><span class="c004">#</span> p'#get_x, p'#color;; </span><span class="c006">- : int * string = (5, "red") </span></pre><p> A point and a colored point have incompatible types, since a point has no method <span class="c007">color</span>. However, the function <span class="c007">get_x</span> below is a generic function applying method <span class="c007">get_x</span> to any object <span class="c007">p</span> that has this method (and possibly some others, which are represented by an ellipsis in the type). Thus, it applies to both points and colored points. </p><pre><span class="c004">#</span><span class="c003"> let get_succ_x p = p#get_x + 1;; <span class="c006">val get_succ_x : < get_x : int; .. > -> int = <fun> </span><span class="c004">#</span> get_succ_x p + get_succ_x p';; </span><span class="c006">- : int = 8 </span></pre><p> Methods need not be declared previously, as shown by the example: </p><pre><span class="c004">#</span><span class="c003"> let set_x p = p#set_x;; <span class="c006">val set_x : < set_x : 'a; .. > -> 'a = <fun> </span><span class="c004">#</span> let incr p = set_x p (get_succ_x p);; </span><span class="c006">val incr : < get_x : int; set_x : int -> 'a; .. > -> 'a = <fun> </span></pre> <h2 class="section" id="sec32">3.9  Multiple inheritance</h2> <p> <a id="ss:multiple-inheritance"></a></p><p>Multiple inheritance is allowed. Only the last definition of a method is kept: the redefinition in a subclass of a method that was visible in the parent class overrides the definition in the parent class. Previous definitions of a method can be reused by binding the related ancestor. Below, <span class="c007">super</span> is bound to the ancestor <span class="c007">printable_point</span>. The name <span class="c007">super</span> is a pseudo value identifier that can only be used to invoke a super-class method, as in <span class="c007">super#print</span>. </p><pre><span class="c004">#</span><span class="c003"> class printable_colored_point y c = object (self) val c = c method color = c inherit printable_point y as super method print = print_string "("; super#print; print_string ", "; print_string (self#color); print_string ")" end;; <span class="c006">class printable_colored_point : int -> string -> object val c : string val mutable x : int method color : string method get_x : int method move : int -> unit method print : unit end </span><span class="c004">#</span> let p' = new printable_colored_point 17 "red";; <span class="c006">new point at (10, red) val p' : printable_colored_point = <obj> </span><span class="c004">#</span> p'#print;; </span><span class="c006">(10, red)- : unit = () </span></pre><p> A private method that has been hidden in the parent class is no longer visible, and is thus not overridden. Since initializers are treated as private methods, all initializers along the class hierarchy are evaluated, in the order they are introduced.</p> <h2 class="section" id="sec33">3.10  Parameterized classes</h2> <p> <a id="ss:parameterized-classes"></a></p><p>Reference cells can be implemented as objects. The naive definition fails to typecheck: </p><pre><span class="c004">#</span><span class="c003"> class <U>ref x_init = object val mutable x = x_init method get = x method set y = x <- y end</U>;; </span><span class="c006">Error: Some type variables are unbound in this type: class ref : 'a -> object val mutable x : 'a method get : 'a method set : 'a -> unit end The method get has type 'a where 'a is unbound </span></pre><p> The reason is that at least one of the methods has a polymorphic type (here, the type of the value stored in the reference cell), thus either the class should be parametric, or the method type should be constrained to a monomorphic type. A monomorphic instance of the class could be defined by: </p><pre><span class="c004">#<span class="c003"> class ref (x_init:int) = object val mutable x = x_init method get = x method set y = x <- y end;; <span class="c006">class ref : int -> object val mutable x : int method get : int method set : int -> unit end </span></span></span></pre><p> Note that since immediate objects do not define a class type, they have no such restriction. </p><pre><span class="c004">#<span class="c003"> let new_ref x_init = object val mutable x = x_init method get = x method set y = x <- y end;; <span class="c006">val new_ref : 'a -> < get : 'a; set : 'a -> unit > = <fun> </span></span></span></pre><p> On the other hand, a class for polymorphic references must explicitly list the type parameters in its declaration. Class type parameters are listed between <span class="c007">[</span> and <span class="c007">]</span>. The type parameters must also be bound somewhere in the class body by a type constraint. </p><pre><span class="c004">#</span><span class="c003"> class ['a] ref x_init = object val mutable x = (x_init : 'a) method get = x method set y = x <- y end;; <span class="c006">class ['a] ref : 'a -> object val mutable x : 'a method get : 'a method set : 'a -> unit end </span><span class="c004">#</span> let r = new ref 1 in r#set 2; (r#get);; </span><span class="c006">- : int = 2 </span></pre><p> The type parameter in the declaration may actually be constrained in the body of the class definition. In the class type, the actual value of the type parameter is displayed in the <span class="c007">constraint</span> clause. </p><pre><span class="c004">#<span class="c003"> class ['a] ref_succ (x_init:'a) = object val mutable x = x_init + 1 method get = x method set y = x <- y end;; <span class="c006">class ['a] ref_succ : 'a -> object constraint 'a = int val mutable x : int method get : int method set : int -> unit end </span></span></span></pre><p> Let us consider a more complex example: define a circle, whose center may be any kind of point. We put an additional type constraint in method <span class="c007">move</span>, since no free variables must remain unaccounted for by the class type parameters. </p><pre><span class="c004">#<span class="c003"> class ['a] circle (c : 'a) = object val mutable center = c method center = center method set_center c = center <- c method move = (center#move : int -> unit) end;; <span class="c006">class ['a] circle : 'a -> object constraint 'a = < move : int -> unit; .. > val mutable center : 'a method center : 'a method move : int -> unit method set_center : 'a -> unit end </span></span></span></pre><p> An alternate definition of <span class="c007">circle</span>, using a <span class="c007">constraint</span> clause in the class definition, is shown below. The type <span class="c007">#point</span> used below in the <span class="c007">constraint</span> clause is an abbreviation produced by the definition of class <span class="c007">point</span>. This abbreviation unifies with the type of any object belonging to a subclass of class <span class="c007">point</span>. It actually expands to <span class="c007">< get_x : int; move : int -> unit; .. ></span>. This leads to the following alternate definition of <span class="c007">circle</span>, which has slightly stronger constraints on its argument, as we now expect <span class="c007">center</span> to have a method <span class="c007">get_x</span>. </p><pre><span class="c004">#<span class="c003"> class ['a] circle (c : 'a) = object constraint 'a = #point val mutable center = c method center = center method set_center c = center <- c method move = center#move end;; <span class="c006">class ['a] circle : 'a -> object constraint 'a = #point val mutable center : 'a method center : 'a method move : int -> unit method set_center : 'a -> unit end </span></span></span></pre><p> The class <span class="c007">colored_circle</span> is a specialized version of class <span class="c007">circle</span> that requires the type of the center to unify with <span class="c007">#colored_point</span>, and adds a method <span class="c007">color</span>. Note that when specializing a parameterized class, the instance of type parameter must always be explicitly given. It is again written between <span class="c007">[</span> and <span class="c007">]</span>. </p><pre><span class="c004">#<span class="c003"> class ['a] colored_circle c = object constraint 'a = #colored_point inherit ['a] circle c method color = center#color end;; <span class="c006">class ['a] colored_circle : 'a -> object constraint 'a = #colored_point val mutable center : 'a method center : 'a method color : string method move : int -> unit method set_center : 'a -> unit end </span></span></span></pre> <h2 class="section" id="sec34">3.11  Polymorphic methods</h2> <p> <a id="ss:polymorphic-methods"></a></p><p>While parameterized classes may be polymorphic in their contents, they are not enough to allow polymorphism of method use.</p><p>A classical example is defining an iterator. </p><pre><span class="c004">#</span><span class="c003"> List.fold_left;; <span class="c006">- : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun> </span><span class="c004">#</span> class ['a] intlist (l : int list) = object method empty = (l = []) method fold f (accu : 'a) = List.fold_left f accu l end;; </span><span class="c006">class ['a] intlist : int list -> object method empty : bool method fold : ('a -> int -> 'a) -> 'a -> 'a end </span></pre><p> At first look, we seem to have a polymorphic iterator, however this does not work in practice. </p><pre><span class="c004">#</span><span class="c003"> let l = new intlist [1; 2; 3];; <span class="c006">val l : '_a intlist = <obj> </span><span class="c004">#</span> l#fold (fun x y -> x+y) 0;; <span class="c006">- : int = 6 </span><span class="c004">#</span> l;; <span class="c006">- : int intlist = <obj> </span><span class="c004">#</span> l#fold (fun s x -> <U>s</U> ^ string_of_int x ^ " ") "";; </span><span class="c006">Error: This expression has type int but an expression was expected of type string </span></pre><p> Our iterator works, as shows its first use for summation. However, since objects themselves are not polymorphic (only their constructors are), using the <span class="c007">fold</span> method fixes its type for this individual object. Our next attempt to use it as a string iterator fails.</p><p>The problem here is that quantification was wrongly located: it is not the class we want to be polymorphic, but the <span class="c007">fold</span> method. This can be achieved by giving an explicitly polymorphic type in the method definition. </p><pre><span class="c004">#</span><span class="c003"> class intlist (l : int list) = object method empty = (l = []) method fold : 'a. ('a -> int -> 'a) -> 'a -> 'a = fun f accu -> List.fold_left f accu l end;; <span class="c006">class intlist : int list -> object method empty : bool method fold : ('a -> int -> 'a) -> 'a -> 'a end </span><span class="c004">#</span> let l = new intlist [1; 2; 3];; <span class="c006">val l : intlist = <obj> </span><span class="c004">#</span> l#fold (fun x y -> x+y) 0;; <span class="c006">- : int = 6 </span><span class="c004">#</span> l#fold (fun s x -> s ^ string_of_int x ^ " ") "";; </span><span class="c006">- : string = "1 2 3 " </span></pre><p> As you can see in the class type shown by the compiler, while polymorphic method types must be fully explicit in class definitions (appearing immediately after the method name), quantified type variables can be left implicit in class descriptions. Why require types to be explicit? The problem is that <span class="c007">(int -> int -> int) -> int -> int</span> would also be a valid type for <span class="c007">fold</span>, and it happens to be incompatible with the polymorphic type we gave (automatic instantiation only works for toplevel types variables, not for inner quantifiers, where it becomes an undecidable problem.) So the compiler cannot choose between those two types, and must be helped.</p><p>However, the type can be completely omitted in the class definition if it is already known, through inheritance or type constraints on self. Here is an example of method overriding. </p><pre><span class="c004">#<span class="c003"> class intlist_rev l = object inherit intlist l method fold f accu = List.fold_left f accu (List.rev l) end;; </span></span></pre><p> The following idiom separates description and definition. </p><pre><span class="c004">#<span class="c003"> class type ['a] iterator = object method fold : ('b -> 'a -> 'b) -> 'b -> 'b end;; class intlist l = object (self : int #iterator) method empty = (l = []) method fold f accu = List.fold_left f accu l end;; </span></span></pre><p> Note here the <span class="c007">(self : int #iterator)</span> idiom, which ensures that this object implements the interface <span class="c007">iterator</span>.</p><p>Polymorphic methods are called in exactly the same way as normal methods, but you should be aware of some limitations of type inference. Namely, a polymorphic method can only be called if its type is known at the call site. Otherwise, the method will be assumed to be monomorphic, and given an incompatible type. </p><pre><span class="c004">#</span><span class="c003"> let sum lst = lst#fold (fun x y -> x+y) 0;; <span class="c006">val sum : < fold : (int -> int -> int) -> int -> 'a; .. > -> 'a = <fun> </span><span class="c004">#</span> sum <U>l</U>;; </span><span class="c006">Error: This expression has type intlist but an expression was expected of type < fold : (int -> int -> int) -> int -> 'a; .. > Types for method fold are incompatible </span></pre><p> The workaround is easy: you should put a type constraint on the parameter. </p><pre><span class="c004">#<span class="c003"> let sum (lst : _ #iterator) = lst#fold (fun x y -> x+y) 0;; <span class="c006">val sum : int #iterator -> int = <fun> </span></span></span></pre><p> Of course the constraint may also be an explicit method type. Only occurences of quantified variables are required. </p><pre><span class="c004">#<span class="c003"> let sum lst = (lst : < fold : 'a. ('a -> _ -> 'a) -> 'a -> 'a; .. >)#fold (+) 0;; <span class="c006">val sum : < fold : 'a. ('a -> int -> 'a) -> 'a -> 'a; .. > -> int = <fun> </span></span></span></pre><p>Another use of polymorphic methods is to allow some form of implicit subtyping in method arguments. We have already seen in section <a href="#ss%3Ainheritance">3.8</a> how some functions may be polymorphic in the class of their argument. This can be extended to methods. </p><pre><span class="c004">#</span><span class="c003"> class type point0 = object method get_x : int end;; <span class="c006">class type point0 = object method get_x : int end </span><span class="c004">#</span> class distance_point x = object inherit point x method distance : 'a. (#point0 as 'a) -> int = fun other -> abs (other#get_x - x) end;; <span class="c006">class distance_point : int -> object val mutable x : int method distance : #point0 -> int method get_offset : int method get_x : int method move : int -> unit end </span><span class="c004">#</span> let p = new distance_point 3 in (p#distance (new point 8), p#distance (new colored_point 1 "blue"));; </span><span class="c006">- : int * int = (5, 2) </span></pre><p> Note here the special syntax <span class="c007">(#point0 as 'a)</span> we have to use to quantify the extensible part of <span class="c007">#point0</span>. As for the variable binder, it can be omitted in class specifications. If you want polymorphism inside object field it must be quantified independently. </p><pre><span class="c004">#<span class="c003"> class multi_poly = object method m1 : 'a. (< n1 : 'b. 'b -> 'b; .. > as 'a) -> _ = fun o -> o#n1 true, o#n1 "hello" method m2 : 'a 'b. (< n2 : 'b -> bool; .. > as 'a) -> 'b -> _ = fun o x -> o#n2 x end;; <span class="c006">class multi_poly : object method m1 : < n1 : 'b. 'b -> 'b; .. > -> bool * string method m2 : < n2 : 'b -> bool; .. > -> 'b -> bool end </span></span></span></pre><p> In method <span class="c007">m1</span>, <span class="c007">o</span> must be an object with at least a method <span class="c007">n1</span>, itself polymorphic. In method <span class="c007">m2</span>, the argument of <span class="c007">n2</span> and <span class="c007">x</span> must have the same type, which is quantified at the same level as <span class="c007">'a</span>.</p> <h2 class="section" id="sec35">3.12  Using coercions</h2> <p> <a id="ss:using-coercions"></a></p><p>Subtyping is never implicit. There are, however, two ways to perform subtyping. The most general construction is fully explicit: both the domain and the codomain of the type coercion must be given.</p><p>We have seen that points and colored points have incompatible types. For instance, they cannot be mixed in the same list. However, a colored point can be coerced to a point, hiding its <span class="c007">color</span> method: </p><pre><span class="c004">#</span><span class="c003"> let colored_point_to_point cp = (cp : colored_point :> point);; <span class="c006">val colored_point_to_point : colored_point -> point = <fun> </span><span class="c004">#</span> let p = new point 3 and q = new colored_point 4 "blue";; <span class="c006">val p : point = <obj> val q : colored_point = <obj> </span><span class="c004">#</span> let l = [p; (colored_point_to_point q)];; </span><span class="c006">val l : point list = [<obj>; <obj>] </span></pre><p> An object of type <span class="c007">t</span> can be seen as an object of type <span class="c007">t'</span> only if <span class="c007">t</span> is a subtype of <span class="c007">t'</span>. For instance, a point cannot be seen as a colored point. </p><pre><span class="c004">#</span> <span class="c003"><U>(p : point :> colored_point)</U>;; </span><span class="c006">Error: Type point = < get_offset : int; get_x : int; move : int -> unit > is not a subtype of colored_point = < color : string; get_offset : int; get_x : int; move : int -> unit > </span></pre><p> Indeed, narrowing coercions without runtime checks would be unsafe. Runtime type checks might raise exceptions, and they would require the presence of type information at runtime, which is not the case in the OCaml system. For these reasons, there is no such operation available in the language.</p><p>Be aware that subtyping and inheritance are not related. Inheritance is a syntactic relation between classes while subtyping is a semantic relation between types. For instance, the class of colored points could have been defined directly, without inheriting from the class of points; the type of colored points would remain unchanged and thus still be a subtype of points. </p><p>The domain of a coercion can often be omitted. For instance, one can define: </p><pre><span class="c004">#<span class="c003"> let to_point cp = (cp :> point);; <span class="c006">val to_point : #point -> point = <fun> </span></span></span></pre><p> In this case, the function <span class="c007">colored_point_to_point</span> is an instance of the function <span class="c007">to_point</span>. This is not always true, however. The fully explicit coercion is more precise and is sometimes unavoidable. Consider, for example, the following class: </p><pre><span class="c004">#<span class="c003"> class c0 = object method m = {< >} method n = 0 end;; <span class="c006">class c0 : object ('a) method m : 'a method n : int end </span></span></span></pre><p> The object type <span class="c007">c0</span> is an abbreviation for <span class="c007"><m : 'a; n : int> as 'a</span>. Consider now the type declaration: </p><pre><span class="c004">#<span class="c003"> class type c1 = object method m : c1 end;; <span class="c006">class type c1 = object method m : c1 end </span></span></span></pre><p> The object type <span class="c007">c1</span> is an abbreviation for the type <span class="c007"><m : 'a> as 'a</span>. The coercion from an object of type <span class="c007">c0</span> to an object of type <span class="c007">c1</span> is correct: </p><pre><span class="c004">#<span class="c003"> fun (x:c0) -> (x : c0 :> c1);; <span class="c006">- : c0 -> c1 = <fun> </span></span></span></pre><p> However, the domain of the coercion cannot always be omitted. In that case, the solution is to use the explicit form. Sometimes, a change in the class-type definition can also solve the problem </p><pre><span class="c004">#</span><span class="c003"> class type c2 = object ('a) method m : 'a end;; <span class="c006">class type c2 = object ('a) method m : 'a end </span><span class="c004">#</span> fun (x:c0) -> (x :> c2);; </span><span class="c006">- : c0 -> c2 = <fun> </span></pre><p> While class types <span class="c007">c1</span> and <span class="c007">c2</span> are different, both object types <span class="c007">c1</span> and <span class="c007">c2</span> expand to the same object type (same method names and types). Yet, when the domain of a coercion is left implicit and its co-domain is an abbreviation of a known class type, then the class type, rather than the object type, is used to derive the coercion function. This allows leaving the domain implicit in most cases when coercing form a subclass to its superclass. The type of a coercion can always be seen as below: </p><pre><span class="c004">#</span><span class="c003"> let to_c1 x = (x :> c1);; <span class="c006">val to_c1 : < m : #c1; .. > -> c1 = <fun> </span><span class="c004">#</span> let to_c2 x = (x :> c2);; </span><span class="c006">val to_c2 : #c2 -> c2 = <fun> </span></pre><p> Note the difference between these two coercions: in the case of <span class="c007">to_c2</span>, the type <span class="c007">#c2 = < m : 'a; .. > as 'a</span> is polymorphically recursive (according to the explicit recursion in the class type of <span class="c007">c2</span>); hence the success of applying this coercion to an object of class <span class="c007">c0</span>. On the other hand, in the first case, <span class="c007">c1</span> was only expanded and unrolled twice to obtain <span class="c007">< m : < m : c1; .. >; .. ></span> (remember <span class="c007">#c1 = < m : c1; .. ></span>), without introducing recursion. You may also note that the type of <span class="c007">to_c2</span> is <span class="c007">#c2 -> c2</span> while the type of <span class="c007">to_c1</span> is more general than <span class="c007">#c1 -> c1</span>. This is not always true, since there are class types for which some instances of <span class="c007">#c</span> are not subtypes of <span class="c007">c</span>, as explained in section <a href="#ss%3Abinary-methods">3.16</a>. Yet, for parameterless classes the coercion <span class="c007">(_ :> c)</span> is always more general than <span class="c007">(_ : #c :> c)</span>. </p><p>A common problem may occur when one tries to define a coercion to a class <span class="c007">c</span> while defining class <span class="c007">c</span>. The problem is due to the type abbreviation not being completely defined yet, and so its subtypes are not clearly known. Then, a coercion <span class="c007">(_ :> c)</span> or <span class="c007">(_ : #c :> c)</span> is taken to be the identity function, as in </p><pre><span class="c004">#<span class="c003"> function x -> (x :> 'a);; <span class="c006">- : 'a -> 'a = <fun> </span></span></span></pre><p> As a consequence, if the coercion is applied to <span class="c007">self</span>, as in the following example, the type of <span class="c007">self</span> is unified with the closed type <span class="c007">c</span> (a closed object type is an object type without ellipsis). This would constrain the type of self be closed and is thus rejected. Indeed, the type of self cannot be closed: this would prevent any further extension of the class. Therefore, a type error is generated when the unification of this type with another type would result in a closed object type. </p><pre><span class="c004">#</span><span class="c003"> class c = object method m = 1 end and d = object (self) inherit c method n = 2 method as_c = (<U>self</U> :> c) end;; </span><span class="c006">Error: This expression cannot be coerced to type c = < m : int >; it has type < as_c : c; m : int; n : int; .. > but is here used with type c Self type cannot be unified with a closed object type </span></pre><p> However, the most common instance of this problem, coercing self to its current class, is detected as a special case by the type checker, and properly typed. </p><pre><span class="c004">#<span class="c003"> class c = object (self) method m = (self :> c) end;; <span class="c006">class c : object method m : c end </span></span></span></pre><p> This allows the following idiom, keeping a list of all objects belonging to a class or its subclasses: </p><pre><span class="c004">#</span><span class="c003"> let all_c = ref [];; <span class="c006">val all_c : '_a list ref = {contents = []} </span><span class="c004">#</span> class c (m : int) = object (self) method m = m initializer all_c := (self :> c) :: !all_c end;; </span><span class="c006">class c : int -> object method m : int end </span></pre><p> This idiom can in turn be used to retrieve an object whose type has been weakened: </p><pre><span class="c004">#</span><span class="c003"> let rec lookup_obj obj = function [] -> raise Not_found | obj' :: l -> if (obj :> < >) = (obj' :> < >) then obj' else lookup_obj obj l ;; <span class="c006">val lookup_obj : < .. > -> (< .. > as 'a) list -> 'a = <fun> </span><span class="c004">#</span> let lookup_c obj = lookup_obj obj !all_c;; </span><span class="c006">val lookup_c : < .. > -> < m : int > = <fun> </span></pre><p> The type <span class="c007">< m : int ></span> we see here is just the expansion of <span class="c007">c</span>, due to the use of a reference; we have succeeded in getting back an object of type <span class="c007">c</span>.</p><p><br> The previous coercion problem can often be avoided by first defining the abbreviation, using a class type: </p><pre><span class="c004">#</span><span class="c003"> class type c' = object method m : int end;; <span class="c006">class type c' = object method m : int end </span><span class="c004">#</span> class c : c' = object method m = 1 end and d = object (self) inherit c method n = 2 method as_c = (self :> c') end;; </span><span class="c006">class c : c' and d : object method as_c : c' method m : int method n : int end </span></pre><p> It is also possible to use a virtual class. Inheriting from this class simultaneously forces all methods of <span class="c007">c</span> to have the same type as the methods of <span class="c007">c'</span>. </p><pre><span class="c004">#</span><span class="c003"> class virtual c' = object method virtual m : int end;; <span class="c006">class virtual c' : object method virtual m : int end </span><span class="c004">#</span> class c = object (self) inherit c' method m = 1 end;; </span><span class="c006">class c : object method m : int end </span></pre><p> One could think of defining the type abbreviation directly: </p><pre><span class="c004">#<span class="c003"> type c' = <m : int>;; </span></span></pre><p> However, the abbreviation <span class="c007">#c'</span> cannot be defined directly in a similar way. It can only be defined by a class or a class-type definition. This is because a <span class="c007">#</span>-abbreviation carries an implicit anonymous variable <span class="c007">..</span> that cannot be explicitly named. The closer you get to it is: </p><pre><span class="c004">#<span class="c003"> type 'a c'_class = 'a constraint 'a = < m : int; .. >;; </span></span></pre><p> with an extra type variable capturing the open object type.</p> <h2 class="section" id="sec36">3.13  Functional objects</h2> <p> <a id="ss:functional-objects"></a></p><p>It is possible to write a version of class <span class="c007">point</span> without assignments on the instance variables. The override construct <span class="c007">{< ... >}</span> returns a copy of “self” (that is, the current object), possibly changing the value of some instance variables. </p><pre><span class="c004">#</span><span class="c003"> class functional_point y = object val x = y method get_x = x method move d = {< x = x + d >} end;; <span class="c006">class functional_point : int -> object ('a) val x : int method get_x : int method move : int -> 'a end </span><span class="c004">#</span> let p = new functional_point 7;; <span class="c006">val p : functional_point = <obj> </span><span class="c004">#</span> p#get_x;; <span class="c006">- : int = 7 </span><span class="c004">#</span> (p#move 3)#get_x;; <span class="c006">- : int = 10 </span><span class="c004">#</span> p#get_x;; </span><span class="c006">- : int = 7 </span></pre><p> Note that the type abbreviation <span class="c007">functional_point</span> is recursive, which can be seen in the class type of <span class="c007">functional_point</span>: the type of self is <span class="c007">'a</span> and <span class="c007">'a</span> appears inside the type of the method <span class="c007">move</span>.</p><p>The above definition of <span class="c007">functional_point</span> is not equivalent to the following: </p><pre><span class="c004">#<span class="c003"> class bad_functional_point y = object val x = y method get_x = x method move d = new bad_functional_point (x+d) end;; <span class="c006">class bad_functional_point : int -> object val x : int method get_x : int method move : int -> bad_functional_point end </span></span></span></pre><p> While objects of either class will behave the same, objects of their subclasses will be different. In a subclass of <span class="c007">bad_functional_point</span>, the method <span class="c007">move</span> will keep returning an object of the parent class. On the contrary, in a subclass of <span class="c007">functional_point</span>, the method <span class="c007">move</span> will return an object of the subclass.</p><p>Functional update is often used in conjunction with binary methods as illustrated in section <a href="advexamples.html#module%3Astring">5.2.1</a>.</p> <h2 class="section" id="sec37">3.14  Cloning objects</h2> <p> <a id="ss:cloning-objects"></a></p><p>Objects can also be cloned, whether they are functional or imperative. The library function <span class="c007">Oo.copy</span> makes a shallow copy of an object. That is, it returns a new object that has the same methods and instance variables as its argument. The instance variables are copied but their contents are shared. Assigning a new value to an instance variable of the copy (using a method call) will not affect instance variables of the original, and conversely. A deeper assignment (for example if the instance variable is a reference cell) will of course affect both the original and the copy.</p><p>The type of <span class="c007">Oo.copy</span> is the following: </p><pre><span class="c004">#<span class="c003"> Oo.copy;; <span class="c006">- : (< .. > as 'a) -> 'a = <fun> </span></span></span></pre><p> The keyword <span class="c007">as</span> in that type binds the type variable <span class="c007">'a</span> to the object type <span class="c007">< .. ></span>. Therefore, <span class="c007">Oo.copy</span> takes an object with any methods (represented by the ellipsis), and returns an object of the same type. The type of <span class="c007">Oo.copy</span> is different from type <span class="c007">< .. > -> < .. ></span> as each ellipsis represents a different set of methods. Ellipsis actually behaves as a type variable. </p><pre><span class="c004">#</span><span class="c003"> let p = new point 5;; <span class="c006">val p : point = <obj> </span><span class="c004">#</span> let q = Oo.copy p;; <span class="c006">val q : point = <obj> </span><span class="c004">#</span> q#move 7; (p#get_x, q#get_x);; </span><span class="c006">- : int * int = (5, 12) </span></pre><p> In fact, <span class="c007">Oo.copy p</span> will behave as <span class="c007">p#copy</span> assuming that a public method <span class="c007">copy</span> with body <span class="c007">{< >}</span> has been defined in the class of <span class="c007">p</span>.</p><p>Objects can be compared using the generic comparison functions <span class="c007">=</span> and <span class="c007"><></span>. Two objects are equal if and only if they are physically equal. In particular, an object and its copy are not equal. </p><pre><span class="c004">#</span><span class="c003"> let q = Oo.copy p;; <span class="c006">val q : point = <obj> </span><span class="c004">#</span> p = q, p = p;; </span><span class="c006">- : bool * bool = (false, true) </span></pre><p> Other generic comparisons such as (<span class="c007"><</span>, <span class="c007"><=</span>, ...) can also be used on objects. The relation <span class="c007"><</span> 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.</p><p>Cloning and override have a non empty intersection. They are interchangeable when used within an object and without overriding any field: </p><pre><span class="c004">#</span><span class="c003"> class copy = object method copy = {< >} end;; <span class="c006">class copy : object ('a) method copy : 'a end </span><span class="c004">#</span> class copy = object (self) method copy = Oo.copy self end;; </span><span class="c006">class copy : object ('a) method copy : 'a end </span></pre><p> Only the override can be used to actually override fields, and only the <span class="c007">Oo.copy</span> primitive can be used externally.</p><p>Cloning can also be used to provide facilities for saving and restoring the state of objects. </p><pre><span class="c004">#<span class="c003"> class backup = object (self : 'mytype) val mutable copy = None method save = copy <- Some {< copy = None >} method restore = match copy with Some x -> x | None -> self end;; <span class="c006">class backup : object ('a) val mutable copy : 'a option method restore : 'a method save : unit end </span></span></span></pre><p> The above definition will only backup one level. The backup facility can be added to any class by using multiple inheritance. </p><pre><span class="c004">#</span><span class="c003"> class ['a] backup_ref x = object inherit ['a] ref x inherit backup end;; <span class="c006">class ['a] backup_ref : 'a -> object ('b) val mutable copy : 'b option val mutable x : 'a method get : 'a method restore : 'b method save : unit method set : 'a -> unit end </span><span class="c004">#</span> let rec get p n = if n = 0 then p # get else get (p # restore) (n-1);; <span class="c006">val get : (< get : 'b; restore : 'a; .. > as 'a) -> int -> 'b = <fun> </span><span class="c004">#</span> let p = new backup_ref 0 in p # save; p # set 1; p # save; p # set 2; [get p 0; get p 1; get p 2; get p 3; get p 4];; </span><span class="c006">- : int list = [2; 1; 1; 1; 1] </span></pre><p> We can define a variant of backup that retains all copies. (We also add a method <span class="c007">clear</span> to manually erase all copies.) </p><pre><span class="c004">#<span class="c003"> class backup = object (self : 'mytype) val mutable copy = None method save = copy <- Some {< >} method restore = match copy with Some x -> x | None -> self method clear = copy <- None end;; <span class="c006">class backup : object ('a) val mutable copy : 'a option method clear : unit method restore : 'a method save : unit end </span></span></span></pre><pre><span class="c004">#</span><span class="c003"> class ['a] backup_ref x = object inherit ['a] ref x inherit backup end;; <span class="c006">class ['a] backup_ref : 'a -> object ('b) val mutable copy : 'b option val mutable x : 'a method clear : unit method get : 'a method restore : 'b method save : unit method set : 'a -> unit end </span><span class="c004">#</span> let p = new backup_ref 0 in p # save; p # set 1; p # save; p # set 2; [get p 0; get p 1; get p 2; get p 3; get p 4];; </span><span class="c006">- : int list = [2; 1; 0; 0; 0] </span></pre> <h2 class="section" id="sec38">3.15  Recursive classes</h2> <p> <a id="ss:recursive-classes"></a></p><p>Recursive classes can be used to define objects whose types are mutually recursive. </p><pre><span class="c004">#<span class="c003"> class window = object val mutable top_widget = (None : widget option) method top_widget = top_widget end and widget (w : window) = object val window = w method window = window end;; <span class="c006">class window : object val mutable top_widget : widget option method top_widget : widget option end and widget : window -> object val window : window method window : window end </span></span></span></pre><p> Although their types are mutually recursive, the classes <span class="c007">widget</span> and <span class="c007">window</span> are themselves independent.</p> <h2 class="section" id="sec39">3.16  Binary methods</h2> <p> <a id="ss:binary-methods"></a></p><p>A binary method is a method which takes an argument of the same type as self. The class <span class="c007">comparable</span> below is a template for classes with a binary method <span class="c007">leq</span> of type <span class="c007">'a -> bool</span> where the type variable <span class="c007">'a</span> is bound to the type of self. Therefore, <span class="c007">#comparable</span> expands to <span class="c007">< leq : 'a -> bool; .. > as 'a</span>. We see here that the binder <span class="c007">as</span> also allows writing recursive types. </p><pre><span class="c004">#<span class="c003"> class virtual comparable = object (_ : 'a) method virtual leq : 'a -> bool end;; <span class="c006">class virtual comparable : object ('a) method virtual leq : 'a -> bool end </span></span></span></pre><p> We then define a subclass <span class="c007">money</span> of <span class="c007">comparable</span>. The class <span class="c007">money</span> simply wraps floats as comparable objects. We will extend it below with more operations. We have to use a type constraint on the class parameter <span class="c007">x</span> because the primitive <span class="c007"><=</span> is a polymorphic function in OCaml. The <span class="c007">inherit</span> clause ensures that the type of objects of this class is an instance of <span class="c007">#comparable</span>. </p><pre><span class="c004">#<span class="c003"> class money (x : float) = object inherit comparable val repr = x method value = repr method leq p = repr <= p#value end;; <span class="c006">class money : float -> object ('a) val repr : float method leq : 'a -> bool method value : float end </span></span></span></pre><p> Note that the type <span class="c007">money</span> is not a subtype of type <span class="c007">comparable</span>, as the self type appears in contravariant position in the type of method <span class="c007">leq</span>. Indeed, an object <span class="c007">m</span> of class <span class="c007">money</span> has a method <span class="c007">leq</span> that expects an argument of type <span class="c007">money</span> since it accesses its <span class="c007">value</span> method. Considering <span class="c007">m</span> of type <span class="c007">comparable</span> would allow a call to method <span class="c007">leq</span> on <span class="c007">m</span> with an argument that does not have a method <span class="c007">value</span>, which would be an error.</p><p>Similarly, the type <span class="c007">money2</span> below is not a subtype of type <span class="c007">money</span>. </p><pre><span class="c004">#<span class="c003"> class money2 x = object inherit money x method times k = {< repr = k *. repr >} end;; <span class="c006">class money2 : float -> object ('a) val repr : float method leq : 'a -> bool method times : float -> 'a method value : float end </span></span></span></pre><p> It is however possible to define functions that manipulate objects of type either <span class="c007">money</span> or <span class="c007">money2</span>: the function <span class="c007">min</span> will return the minimum of any two objects whose type unifies with <span class="c007">#comparable</span>. The type of <span class="c007">min</span> is not the same as <span class="c007">#comparable -> #comparable -> #comparable</span>, as the abbreviation <span class="c007">#comparable</span> hides a type variable (an ellipsis). Each occurrence of this abbreviation generates a new variable. </p><pre><span class="c004">#<span class="c003"> let min (x : #comparable) y = if x#leq y then x else y;; <span class="c006">val min : (#comparable as 'a) -> 'a -> 'a = <fun> </span></span></span></pre><p> This function can be applied to objects of type <span class="c007">money</span> or <span class="c007">money2</span>. </p><pre><span class="c004">#</span><span class="c003"> (min (new money 1.3) (new money 3.1))#value;; <span class="c006">- : float = 1.3 </span><span class="c004">#</span> (min (new money2 5.0) (new money2 3.14))#value;; </span><span class="c006">- : float = 3.14 </span></pre><p>More examples of binary methods can be found in sections <a href="advexamples.html#module%3Astring">5.2.1</a> and <a href="advexamples.html#module%3Aset">5.2.3</a>.</p><p>Note the use of override for method <span class="c007">times</span>. Writing <span class="c007">new money2 (k *. repr)</span> instead of <span class="c007">{< repr = k *. repr >}</span> would not behave well with inheritance: in a subclass <span class="c007">money3</span> of <span class="c007">money2</span> the <span class="c007">times</span> method would return an object of class <span class="c007">money2</span> but not of class <span class="c007">money3</span> as would be expected.</p><p>The class <span class="c007">money</span> could naturally carry another binary method. Here is a direct definition: </p><pre><span class="c004">#<span class="c003"> class money x = object (self : 'a) val repr = x method value = repr method print = print_float repr method times k = {< repr = k *. x >} method leq (p : 'a) = repr <= p#value method plus (p : 'a) = {< repr = x +. p#value >} end;; <span class="c006">class money : float -> object ('a) val repr : float method leq : 'a -> bool method plus : 'a -> 'a method print : unit method times : float -> 'a method value : float end </span></span></span></pre> <h2 class="section" id="sec40">3.17  Friends</h2> <p> <a id="ss:friends"></a></p><p>The above class <span class="c007">money</span> reveals a problem that often occurs with binary methods. In order to interact with other objects of the same class, the representation of <span class="c007">money</span> objects must be revealed, using a method such as <span class="c007">value</span>. If we remove all binary methods (here <span class="c007">plus</span> and <span class="c007">leq</span>), the representation can easily be hidden inside objects by removing the method <span class="c007">value</span> as well. However, this is not possible as soon as some binary method requires access to the representation of objects of the same class (other than self). </p><pre><span class="c004">#<span class="c003"> class safe_money x = object (self : 'a) val repr = x method print = print_float repr method times k = {< repr = k *. x >} end;; <span class="c006">class safe_money : float -> object ('a) val repr : float method print : unit method times : float -> 'a end </span></span></span></pre><p> Here, the representation of the object is known only to a particular object. To make it available to other objects of the same class, we are forced to make it available to the whole world. However we can easily restrict the visibility of the representation using the module system. </p><pre><span class="c004">#<span class="c003"> module type MONEY = sig type t class c : float -> object ('a) val repr : t method value : t method print : unit method times : float -> 'a method leq : 'a -> bool method plus : 'a -> 'a end end;; module Euro : MONEY = struct type t = float class c x = object (self : 'a) val repr = x method value = repr method print = print_float repr method times k = {< repr = k *. x >} method leq (p : 'a) = repr <= p#value method plus (p : 'a) = {< repr = x +. p#value >} end end;; </span></span></pre><p> Another example of friend functions may be found in section <a href="advexamples.html#module%3Aset">5.2.3</a>. These examples occur when a group of objects (here objects of the same class) and functions should see each others internal representation, while their representation should be hidden from the outside. The solution is always to define all friends in the same module, give access to the representation and use a signature constraint to make the representation abstract outside the module.</p> <hr> <a href="moduleexamples.html"><img src="previous_motif.gif" alt="Previous"></a> <a href="index.html"><img src="contents_motif.gif" alt="Up"></a> <a href="lablexamples.html"><img src="next_motif.gif" alt="Next"></a> </body> </html>