Re: Q: Endless loop by dispatching

["Robert I. Eachus" <rieachus@attbi.com>]

Dmitry A. Kazakov wrote:

> One should invent a good syntax suggar for this. Which is rather
> difficult. There are actually two things in it:

That is putting it VERY mildly.

> 1. There should be a way to declare some primitive operation saying
> that it cannot be overriden completely. One might wish it for things
> like Initialize/Finalize. Then probably there should be a way to say
> where an override is allowed to add something.
> 
> 2. During overriding one should specifiy where the override(s) places
> the extension. I think that it should be specified in the body, while
> the specification should only say that it gets overridden.
> 
> The question is syntax and a good balance between 1. and 2., i.e
> between contract and implementation. The most complicated cases would
> emerge from things like Adjust, I suppose.

 > It is also related to an ability to explicitly specify that a
 > subroutine is an overriding, not overloading, to avoid undesired
 > overloading in case ot typo errors. I do not know whether there is an
 > AI on that. If yes, they should be considered together.


There is an AI on this  (AI-218).  If you try to follow the discussion, 
you eyes will quickly glaze over.  It needs to be fixed, it probably 
will be fixed, but there is a slight problem.  There can be multiple 
views of a subprogram declaration, and in some views it will be 
overriding, while in others it is not.  This is both why a "confirming" 
keyword is currently the leading candidate for Ada0Y, and why it is so 
hard. We don't want a solution that requires a programmer to explicitly 
confirm the wrong view:

package P is

    type T is tagged private;

private

    type T is new Ada.Finalization.Controlled with...;

end P;

package P.Q is

   type NT is new T;

   procedure Initialize(X: in out NT); -- overriding?  Not here.

private
   -- but it is here.

   procedure Finalize(X: in out NT); -- overriding?  Yes, and here.

end P.Q;

I favor the pragma solution, because you can put the pragma at the point 
where it says "but it is here," and not confuse anyone.  Most ARG 
members seem to prefer the keyword solution, which requires an "extra" 
declaration at that point just to use the keyword.

Note that 90% of the potential uses are simple.  The other 10% are cases 
where the compiler will probably end up providing education to Ada 
programmers.  Getting that education as painless as possible is the real 
problem.

-- 

                                                        Robert I. Eachus

�In an ally, considerations of house, clan, planet, race are 
insignificant beside two prime questions, which are: 1. Can he shoot? 2. 
Will he aim at your enemy?� -- from the Laiden novels by Sharon Lee and 
Steve Miller.