This message identical to the post I made to comp.lang.ml a while back
- but I think it will have a better audience over here, now that I
decided to join the list.

---

Lately I've been having a bit of a dilemma caused by a bottleneck from
object-oriented access in Ocaml. The problem derives from the
implementation of method calls through lazy binding.

Compiled languages which offer an object oriented system usually
provide a way for methods to short-circuit the lazy binding (or
virtual function table) system. In C++, non-virtual functions do this,
in Java, declaring a method final gives the compiler a hint about
this. In this case, the compiler can inline the method into the
caller.

Ocaml doesn't seem to be provide such a way. Upon closer inspection it
is obvious how this is so - if we allow subtyping by coercion, we have
no idea of the underlying implementation of the object given to the
function - where as when inheritance relationships are traditionally
forced in languages, we know that the implementation is composed of
the class atleast.

So, the obvious solution is to write the functions that do not need
the lazy binding outside the class itself, as normal functions. But
that doesn't help either - because there's no way to access data in
the object without going through a lazy binding call again.

What this all amounts to is that you cannot store data inside classes
at all, if some parts of it might require performance critical
work. The problem can be lessened by placing the data in a record,
which is only referenced from the object and passed around - or
something similar - but that adds complexity into the whole thing.

And theoretically if you absolutely *know* what type your object is
and that it isn't subtyped, you could use the direct field accesses in
Obj, but that amounts to major hackery already.

So - I am asking if I'm correct in my deductions here, or if I missed
some important point. Or if there's an alternative way to circumvent
this restriction.

To summarize - is there any way to have some function (or method or
whatever) that is able to access object member data, without the
overhead of a lazy binding function call? Preferably ofcourse such a
function should be eligible to be inlined.

Thanks in advance,
-- Naked

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners