Re: Your wish list for Ada 202X

[Natasha Kerensikova <lithiumcat@instinctive.eu>]

Hello,

On 2014-04-15, Randy Brukardt <randy@rrsoftware.com> wrote:
> "Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
> news:br07nkFnvrbU1@mid.individual.net...
> ...
>> (This is why I don't understand your and Randy's abhorrence of
>> re-dispatching -- to me, there is no basic difference between
>> dispatching calls in class-wide operations, and re-dispatching calls in
>> primitive operations.)
>
> [...]
>
> Finally (really a restating of the last point), I find that it's fairly easy 
> to ensure that all of the primitive operations of a particular type have the 
> same world-view. That's not as true when some of the operations are assuming 
> the object is of type T, and some are re-dispatching to some TT derived from 
> T -- I've found many instances where some predicate of TT gets a different 
> answer than the same predicate of the same object viewed as a T. That sort 
> of things leads to all kinds of bugs, because not all of those predicates 
> are explicit in the code (even as statically bound calls).
>
> This last issue doesn't arise for a class-wide operation, where every call 
> is going to look at an object of TT as type TT. And that's really the major 
> difference between "dispatching" and "re-dispatching".

Thanks for the explanation, but I'm a bit lost where the situation I
have encountered the most fits in "dispatching" vs "re-dispatching":

let's consider an abstract type T, with an abstract operation AO and a
huge part of the algorithm implemented in primitive operations for T,
making use of AO. Concrete descendants of T are supposed to implement
AO, and inherit the rest without overriding.

Then in T subprograms I end up with things that look like:
   AO (T'Class (Self), Other, Arguments);


I've always thought of this as "re-disatching". Is it?

Is it somehow more acceptable? (maybe it doesn't make any sense to
consider it as some "predicate with the same object viewed as T")

Are there better language facilities to use in such situations?
(I used to use generics for that, and still do when there is absolutely
no plan for any child package)


Thanks for the clarification,
Natasha