Re: [Caml-list] Class/prototype-based OO

[Gerd Stolpmann <info@gerd-stolpmann.de>]

Am Montag, den 28.08.2006, 20:11 -0700 schrieb Ted Kremenek:
> On Aug 25, 2006, at 4:31 AM, skaller wrote:
> 
> > Thus, from a software engineering viewpoint, nominal typing
> > is not a viable option .. which is one reason programming
> > in Java or C++ using OO sucks.
> >
> > In Ocaml, it works much better because you can actually
> > write algorithms which work with many different types,
> > provided only they support the 'right methods'.
> 
> While the structural typing in Ocaml is wonderful (I really love it),  
> there are missing features of the OO system in OCaml that can be  
> particularly bothersome, and are worth considering when comparing the  
> OO features of Ocaml with other languages (including those that use  
> nominal typing).

That sounds a bit like as if the OO language with more features was the
better one. The problem is that certain features are incompatible with
each other, at least in a practical sense, i.e. you cannot have good and
efficient implementations for all.

> For example, from what I can tell it appears that Ocaml lacks real  
> support for "downcasts" in the language, which require run-time type  
> information (RTTI) and run-time checks.  

In theory, RTTI is possible in O'Caml. But it is very costly: Object
types are complex structures and not only names. So any downcast would
be a very expensive operation (a full type check).

> In the context of structural  
> typing, I am talking about "casting" an object with a type with a  
> given set of method signatures to another type with an extended set  
> of method signatures.  Whether or not you agree downcasts are a good  
> thing, it is one thing to take into account when comparing the OO  
> features of different languages (and this is a feature that both C++  
> and Java have that OCaml does not).  In general, I don't believe the  
> OO system in Ocaml supports any kind of RTTI, which enables features  
> such as downcasts and reflection.  All of the type checking of  
> objects in OCaml is static, which is very nice but often insufficient.

Please note that OCaml is not only OO, so if you observe that you need
downcasts often, you probably have an inappropriate programming style.

For example, if you want to have a user-extensible data structure, you
normally implement it with modules and parametric polymorphism. If the
user of this structure wants to store different things into the same
structure, one can define a variant type. (Well, I know that OO
enthusiasts have a lot of prejudices against variants, mostly because
they never saw which role variants can play in a polymorphism-rich
language.)

> Actually, if I am wrong about this I would be very happy if someone  
> out there can point this out.  Certainly one can implement downcasts  
> using Obj.magic and some hand-crafted RTTI, but that is obviously not  
> a desired solution.

Certainly not this way. Simply use exceptions for home-made RTTI:

class type foo = ...

exception Foo of foo

class foo_class : foo =
object(self)
   ...
   method downcast = raise(Foo(self : #foo :> foo))
end


let downcast_foo (obj : < downcast : unit; ..>) =
  try obj # downcast
  with Foo x -> x
     | _ -> failwith "This is not a foo!"


Although this is restricted to monomorphic types please note that the
other languages you mention only have this sort of types.

Gerd
-- 
------------------------------------------------------------
Gerd Stolpmann * Viktoriastr. 45 * 64293 Darmstadt * Germany 
gerd@gerd-stolpmann.de          http://www.gerd-stolpmann.de
Phone: +49-6151-153855                  Fax: +49-6151-997714
------------------------------------------------------------