Re: Limited_Controlled, orthogonality and related issues

["Adam Beneschan" <adam@irvine.com>]

Dmitry A. Kazakov wrote:

> > On reflection, maybe there *is* a way to fix this: Change the first
> > sentence of 3.9.2(1) to read, "The primitive subprograms of a tagged
> > type are called dispatching operations, except that a primitive
> > subprogram of two or more tagged types is not a dispatching operation
> > if it is declared in the visible part of a package, and every type of
> > which the subprogram is a primitive operation is an untagged type or a
> > tagged type whose partial view is untagged".  Or something along those
> > lines.  The idea is that a change like this would have no effect on
> > programs that are currently legal, so it seems like it should be safe.
> > And it would make programs like Maciej's original attempt legal, as
> > they (IMHO) should be.
>
> I think that this idea is wrong because it fixes broken public view
> [non-tagged but dispatching], by breaking the private view [non-dispatching
> but tagged].

It's certainly a "hack" solution that would introduce an inconsistency
into the language, but that certainly wouldn't be the first time
something inconsistent was added to Ada, in order to try to fix a
problem while having minimal effect on existing programs.  Unless I've
missed something, the hack solution I proposed would affect *only*
programs that are currently illegal while having no effect on the
semantics of currently legal programs, so from that standpoint I don't
see how it "breaks" anything.

However, now that I've seen Randy's post, I'm convinced that there are
less onerous ways to get around the problem---you can arrange things so
that you can declare this subprogram and still implement the full views
of the types any way you wish.  So there's probably less of a reason to
add a "hack" like this to the language than there was when I first
posted it.

I think that your idea below is possibly a good reflection of how
things *should* have been designed, in theory; but I think it could
break existing programs if we tried to add that now.  I'm afraid that
not enough consideration was given to the special problems of untagged
private types whose full view is tagged when Ada 95 was designed; as I
recall, I've found areas of the RM that were worded in a way that made
it unclear what should happen with such types.

                                -- Adam


> I think that the guiding rule should be that all views of the
> same thing shall be consistent. For this reason it would be better that for
> such subprograms the private view of such subprograms were class-wide:
>
> package
>    type T is limited private;
>    procedure Foo (X : in out T);
> private
>    type T is new Ada.Finalization.Limited_Controlled with ...;
> --
> -- Here Foo is seen as
> --
> --    procedure Foo (X : in out T'Class);