Re: Your wish list for Ada 202X

["Randy Brukardt" <randy@rrsoftware.com>]

"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.)

I don't think it is a good idea to assume that Dmitry and I have the same 
opinion on anything, even if the result appears to be the same. :-)

I view dispatching operations as the low-level primitives of a type, while 
class-wide operations (which actually involve dispatching) as higher-level 
operations of the type. As such, a re-dispatching call means that there is 
some sort of abstraction inversion going on, and that's usually (but not 
always) bad.

Dispatching operations necessarily have weaker contracts than statically 
bound calls, and that is especially important for "contracts" that can't be 
described in Ada and thus can't be checked (either statically or 
dynamically). After all, most extensions are created by someone other than 
the originator of the original class, so violations of those implicit 
contracts are bound to happen. (Errors happen any time humans are involved!) 
Thus, you have much more confidence in operations that don't involve 
re-dispatching -- as a practical matter, it is a lot easier to debug 
statically bound calls rather than dispatching ones.

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".

Perhaps I'm just being too conservative here, but I do like being able to 
get things to work as expected.

                                      Randy.