Re: Strange error message

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

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> The first objection is that the legality of inheriting Create in
>
>    type Base is tagged private;
>    function Create return Base;
>
>    type High is new Base with private;
>  
> depends on the private part of the package. This is not good.

Privacy breakage is not good, but there is no privacy breakage here.
Privacy breakage happens when the legality of clients depends on the
contents of the private part.  Here, the legality of the package itself
depends on the contents of the private part (which is always the case!).

Clients can only see the visible part as quoted above.
The private part could be:

    private
       type Base is tagged null record;
       type High is new Base with null record;

or:

    private
       type Base is tagged null record;

       type High is new Base with record
          H_Val : Natural;
       end record;
       overriding function Create return High is
         (Base'(Create) with H_Val => <>);

both of which are legal.  The visible part promises that there
will be a function Create returning High.  The first private part
above accomplishes that by using the one implicitly generated
by the compiler, which looks like this:

       function Create return High is (Base'(Create) with null record);

If you wrote it by hand (as you were required to do in Ada 95), you
would almost certainly write something equivalent.  What else could it
reasonably do?

The compiler can't automatically create Create in the second case,
because it doesn't know what value you want for H_Val.

> The second objection is, if the above is not good then
>
>    type High is new Base with null record;
>
> should make no difference.

Well, since your first objection is invalid, the premise of
your second objection is false.  ;-)

> ---------------
> Of course one could argue in favor of the rule that all primitive
> operations are in some sense overridden anyway. It is only the way the
> bodies are constructed (inherited vs. provided by the user), what makes
> difference. I.e. whether
>
>    overriding function Create return High;
>
> appears in the public part of the package or not, that is an implementation
> detail uninteresting to the clients. I would agree with that, but it is not
> how the language is designed presently.

Not sure what you mean.  You can put the above "overriding..." in the
visible part or the private part, or (in the null record case) leave it
out.  It makes no difference to clients.

> It is, as always, too late, but probably overriding (with new body) were to
> appear strictly in the package body.

Yes, that would make sense.  I suggested that during Ada 9X.  The
reasons not to do that have to do with making compilers easier to write.

In fact, private parts should not exist; that stuff belongs in the body.

>...Then the rule of null extension would
> be all OK to me.

Is it OK with you now, having read my comments above?

- Bob