Re: Inherited Methods and such

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

Maciej Sobczak <see.my.homepage@gmail.com> writes:

> On 28 Wrz, 02:44, "Randy Brukardt" <ra...@rrsoftware.com> wrote:
>
>> > 1. I don't have to redispatch from Initialize, I can do this from
>> > subprogram S1, which was called from S2, which was called from ... SN,
>> > which was called from Initialize.
>>
>> Of course, that's why it can't be banned. But it is still wrong.

It could be banned by a run-time check.  It seems to me that could be
implemented without distributed overhead:  initially set the tag of
the object to point to a dummy type descriptor, whose dispatch table
entries all point to a "raise-exception" procedure.  When construction
is considered complete, set the tag to the real tag.

But run-time checks are unsatisfying.  I can't see how to do it at
compile time without major violence to the Ada language design.

>... I would go
>> so far as to suggest that *calling out* from Initialize with an object of
>> the type (or an ancestor) is wrong (with the single exception of calling a
>> parent's Initialize routine). But that might be going too far.
>
> It might be good as a coding convention, though.

I think forbidding "calling out" is going too far.  One should always be
allowed to wrap up some piece of code in a subroutine.  (That's one
reason I don't like accept statements -- they have to appear physically
inside a task body, not inside a procedure called by the task body.)

> BTW - your argument about covering this issue with education is
> dangerous - someone might use it against you the next time anybody
> criticizes "other" languages for being error prone... ;-)

Indeed.  But error-pronedness is relative.

- Bob