Re: [Caml-list] Question about objects and method overriding

[Alain Frisch <alain@frisch.fr>]

On 02/03/2014 11:35 AM, Goswin von Brederlow wrote:
> On the source level you can change a method by inheriting the old
> class and implementing the method again. But you seem to want to
> change the method at runtime. Problem there is that all instances of a
> class afaik have the same virtual table to dispatch methods. So
> changing a methong in one instance would change it in all.

Well, nothing prevent you from creating a fresh copy of the table for 
the new object, as in:

let unsafe_override (o : 'a) (ov : < .. >) : 'a =
   let o = Obj.repr (Oo.copy o) in
   let meths = Obj.dup (Obj.field o 0) in
   Obj.set_field o 0 meths;
   let nmeths : int = Obj.magic (Obj.field meths 0) in

   let ov = Obj.repr ov in
   let new_meths = Obj.field ov 0 in
   let nnew_meths : int = Obj.magic (Obj.field new_meths 0) in
   let i = ref 0 and j = ref 0 in
   while !i < nmeths && !j < nnew_meths do
     let tag : int = Obj.magic (Obj.field meths (3 + 2 * !i)) in
     let ntag : int = Obj.magic (Obj.field new_meths (3 + 2 * !j)) in
     if tag < ntag then incr i
     else if ntag < tag then incr j
     else begin
       let f : _ -> _ = Obj.magic (Obj.field new_meths (2 + 2 * !j)) in
       Obj.set_field meths (2 + 2 * !i) (Obj.magic (fun _ -> f ov));
       incr i;
       incr j
     end
   done;
   Obj.magic o


val unsafe_override : (< .. > as 'a) -> < .. > -> 'a = <fun>


This function returns a copy of its first argument (with the same type), 
where the methods which are also defined in the second argument are 
overridden with the implementation from the second argument (and when 
they are called, their "self" is the second argument).

This is type-unsafe because one should enforce that methods common to 
the two objects have the same type (and that there is no clash between 
the hash value of their other methods).  Is there a user-land hack to 
encode this property (or a stronger one, such as the type of the first 
argument be an extension of the type of the second argument)?

For a given list of methods, one can define safe (I believe!) instances 
of unsafe_override, for instance:

let override_x_y : (< x : 'x; y : 'y; .. > as 'this) -> < x : 'x; y : 'y 
 > -> 'this = unsafe_override;;


This function can be used to override methods x and y of an object 
having these methods and potentially more.

Some syntactic sugar could automate this a little bit.  For instance, 
with extension points, one could use a -ppx filter to rewrite:

  [#oo_override x y]

into:

(unsafe_override : (< x : 'x; y : 'y; .. > as 'this) -> < x : 'x; y : 'y 
 > -> 'this)

(with same more unique names for the generated type variables)




Alain