Re: Limited_Controlled, orthogonality and related issues

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

Maciej Sobczak wrote:
> Hi,
>
> Consider the following problem:
>
> package P is
>     type T is limited private;
>     type S is limited private;
>     procedure Do_The_Job(X : in T; Y : in S);
>     -- and gazillion of other subprograms like Do_The_Job
> private
>     -- ...
> end P;
>
> At some point I decide to add automatic destruction to T and S, so the
> package becomes:
>
> with Ada.Finalization;
> package P is
>     type T is limited private;
>     type S is limited private;
>     procedure Do_The_Job(X : in T; Y : in S);
>     -- and gazillion of other subprograms like Do_The_Job
> private
>     type T is new Ada.Finalization.Limited_Controlled with -- ...
>     type S is new Ada.Finalization.Limited_Controlled with -- ...
> end P;
>
> Suddenly, the package no longer compiles:
>
> "operation can be dispatching in only one type"
>
> By making T and S controlled types, they became tagged and Do_The_Job is
> now incorrect.

On looking at this, I wonder if this was an error in the design of Ada
95.  Primitive operations of tagged types are dispatching, and the
reason is that so that another package can declare a type extension
from a tagged type and inherit the dispatching operation, and possibly
override it, and then somebody could use the operation on a class-wide
type to call the correct operation for that particular object, and thus
achieve polymorphism.  But when  the partial view of a type is not
tagged, then other packages can't derive type extensions from it and
can't apply 'Class to it, so was there any logical reason why an
operation on that type (declared in the visible part of the package)
should be dispatching?  Maybe not, since the dispatch could "almost
never" take place in practice, and since making the operation
dispatching adds restrictions just like the one Maciej found.

I say "almost never" because in theory, since the private part or body
of P or of a child of P (or the visible part of a private child of P)
*could* derive a type extension from the tagged type and dispatch.  But
I'd guess that such usage would be rare.

So it seems to me that (1) it would have been better to say in 3.9.2
that a primitive operation of an untagged private type whose full view
is tagged is not dispatching, at least if the operation is declared in
the visible part of the package; or (2) some way should have been
provided for the programmer to specify that an operation that 3.9.2
defines as "dispatching" really isn't.

Maybe (2) is still possible.  I'm guessing that it's way too late to
make (1) the rule.  So this is probably really just a useless rant.

Has this issue been discussed somewhere else, by the way?

                           -- Adam