]> Johan Baltié wrote: > > I do not agree with you on the usefullness of this kind of stuff. > Basic OO theory says that the inheritance relation can be seen as a "is a" operator. > > If your "is a" means "is a with some variants", for me your modelization is not > good. > > You should have: > > B' inherits A > B inherits B' > small_b_variant inherits B' > > Like this code factorisation seems to be easy to do. > > IMHO it's a good modelization constraint to forbid such stuff. I strongly disagree. Inheritance, as pointed out previously by someone on this list (I can't remember whom), is a syntactic property of classes, whereas subtyping is a semantic property of instances. Just now I have received a post by John Prevost clarifying this. In my code, class a = object method m = ... end Provides basic functionality common to all my inheritance hiearchy. Class a *also* defines the actual type of all my inheritance hieararchy, so I do not use subtyping at all; I use type *identity*. That's because I'm building a graph of objects of different classes, so all the objects in the graph need to have the same type. I only use inheritance because of code sharing. Now, class b = object inherit a ... end performs extensive personalizations to the functionality provided by class a, while always retaining the functionality of the parent, which is accessed by sending messages to super_a. Class var_b needs most of the functionality provided by b, with the sole exception of one method, which I call here m, which needs to be identical to the one defined in the root of the hierarchy. Hence, for the sake of code reuse, since var_b shares most of its code with b, it must inherit from b; however, for the sake of not having multiple copies of the same lines of code--a maintainance issue--I *also* need var_b to inherit, albeit indirectly, form a. This is my reason for requesting and "explicit inheritance hierarchy" construct. I think it should pose no semantic issues with the OO system of Caml. It should simply allow explicit scoping of inherited methods. Please, note that it is merely a bit of syntactic sugar. To think of it, it might even be implemented with CamlP4. CamlP4 could perform the following code transformation: class a = object method m = <some stuff> end to class a = object private method __class_a__m = <some stuff> method m = self # __class_a__m end and class var_b = object inherit a as super_a through b as super_b method m = super_a # m end to class var_b = object inherit b as super_b method m = __class_a__m end Daniel, I'm no CamlP4 guru. Would this scheme work? Alex ------------------- 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