Comment author: administrator

Full_Name: chris quinn

Why is it that a class type is not analogous to signatures by being
applicable to a class containing extra methods which require hiding?

class type t = object end

class ic = object
method x = 0
end

class t' arg1 arg2 : t = object
inherit ic
end

The compiler complains that method x cannot be hidden.

IIRC, the reason is two-fold.
A first reason is a consequence of a difference in the way public and
private methods are called.
For public methods, they are searched by name in the method table
(it's more efficient than that, but this is the semantics)

So we could consider the following situation

class c : object method y : float end =
object (self)
method x = 1.0
method = self#x +. 2.0
end

class d = object
inherit c
method x = 1
end

let _ = (new d)#y

Since public methods are looked up by name, self#x becomes 1 rather
than 1.0, and you get a segmentation fault!

The second reason is that the relation required between the interface
and the implementation is not so clear: one could think about allowing
more (with a different implementation), but where to stop? Is full
subtyping OK? Not always.

Note the presence of arguments to class t' - I want to define functions
in terms of a class type free of types of arguments used in construction.
Therefore I must specify an explicit class type, in this case t.
And the only way I can find to accommodate the compiler is
to declare in t' :
method private x = x

Private methods use private labels in place of names, and a different
label is created when a method is hidden. As a result, the two methods
x would have a different label, and self#x would call the first one.
Safe!

There is really nothing wrong in having only private methods, since
you can make them public as soon as needed:

class c : object method x : int end =
object method private x = 0 end

In my situation I have a lot of classes inheriting class ic and
whenever I add a method to it I must revisit them all and add the
above line!

You can define only private methods in your base class, and inherit
them as private or public as you wish.

Jacques

Comment author: administrator

Hiding public methods is indeed unsound.