Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
Re: subtyping and inheritance
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Giuseppe Castagna <Giuseppe.Castagna@e...>
Subject: Re: subtyping and inheritance
Sorry to reopen a thread that is more than 2 months old, but I'm not on the
Caml-List and just today Hugo Herbelin hinted me that some of my work has been
discussed on it. So let me add my two cents worth contribution. 

> [...]
> > So far it seems that things would be unsafe with covariance. But now,
> > Castagna answers my (former) question, whether making "reappear" methods
> > from ancestors would be safe: it is...
> > 
> > The paper looked difficult at first, but turned out to be surprisingly
> > easy to read: Castagna makes the theorie very intuitively clear with his
> > examples of classes "2DPoint" and "3DPoint" and how methods are chosen
> > in the different models.
> > 
> > The record based method (as found in OCAML - the object (record)
> > determines, which method is selected, arguments are not considered)
> > can be obviously extended to support covariance.
> However, it is not possible to apply this extension to Ocaml. Indeed,
> it requires that methods are chosen depending on the dynamic type of
> their arguments. But this information is not available in Ocaml.
> There are also difficulties for type inference.

Jerome is right when he says that dynamic type information is not available 
in Ocaml. Nevertheless I would not be so sure that this means that it is not 
possible to apply this extension to Ocaml. Surely, it would require some 
modifications to the compiler, but all it would have to do is to mark some
particular methods and all the objects that could call these methods by a 
natural number (for those who know, some sort of De Brujin notation, that a
purist may consider as dynamic type information). How to do it in practice is 
described for the language O2 in [1] (but without the natural numbers since
in O2 the dynamic type information is available). This is obtained by simply
modifying the compiler without affecting the language. 

Furthermore if you do not mind to extend the language (notice I said "extend" 
and not "modify") then you can do very nice things. This has been done AND 
implemented for Java. The extension of Java by "encapsulated multi-methods" 
(that's how we christened them) is described in [2]. This is obtained by simply
adding a modifier to Java's syntax. We also have a compiler under Solaris that 
compiles this Java extension. It is interesting to note that it is a
extension of Java, which simply means that if you feed the extended compiler by
standard Java program you will obtain the same code as with the standard
(well, not exactly, object structures will have an extra useless slot).

Let me end with some advertising. Both references should be much easier to read 
than the paper of mine cited in the previous messages. They can be retrieved at
If somebody would like to try to implement it in OCaml I'm ready to help him on
design part (e.g. a student looking for a subject for master thesis ;-)



[1] J.Boyland and G. Castagna. Type-Safe Compilation of Covariant
A Practical Case. In Proc. of ECOOP'96. Lecture Notes in Computer Science, 
1098:3-25, 1996.

[2] J. Boyland and G. Castagna. Parasitic methods: an implementation of 
multi-methods for Java. In Proc. of OOPSLA'97. SIGPLAN Notices 32(10):66-76. 

P.S. We did not made the compiler public available. So there is no doc, etc.,
etc. ...