Re: Interfaces

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Florian Weimer <fw@deneb.enyo.de> writes:

> Suppose there are two interface types, J1 and J2, and the following
> dispatching subprogramms:
> 
>   procedure Foo (Obj : J1);
>   procedure Foo (Obj : J2;
> 
> T implements both J1 and J2, and provides a body for
> 
>   procedure Foo (Obj : T);
> 
> As far as I understand the Ada 200x spec, this subprogram declaration
> overrides both versions of Foo, such that
> 
>   Foo ((J1 (T_Obj));
>   Foo ((J2 (T_Obj));
> 
> invoke the same subprogram.  Is this correct?

I believe so.

> I don't think this is a desirable approach because it makes interfaces
> a strictly non-modular concept, and might force library designers to
> add unique prefixes to interface subprogram names.

Perhaps.

If you override a procedure, you need to obey the comments on the
original declaration, which specify what it is supposed to (or allowed
to) do.  If you override two things at once, you have to obey two
(possibly different) contracts.  If you find you can't do that,
you've got a name clash.  The usual way to fix it is to change one of
the names.

If you choose descriptive names (not "Foo" ;-)) name clashes will be
rare.

If those two Foo's came from two separate third-partly libraries, then
it can be painful or impossible to change the name.  Various workarounds
are possible.  Look at Eiffel for one possible solution to this
problem.  It's pretty complicated, and could cause some confusion
(for example, Bar overrides Foo, because somewhere in the chain of
derivations somebody renamed Foo to Bar).

I was at an ARG meeting a while ago where this name-conflict problem was
discussed.  At first, I advocated solving it (perhaps with an
Eiffel-like solution, perhaps some other solution).  One response was
that we should solve this problem if and when Ada becomes so popular
that there are zillions of libraries causing name conflicts.  ;-)
But the main argument against solving this problem is that it would
introduce a huge amount of complexity to solve a fairly rare problem.
I was pretty-much convinced by that.

Ada's interfaces were modeled primarily after Java's interfaces, by the
way.

- Bob