Re: Access types as parameters

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

"Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
news:4a83d018$0$26303$4f793bc4@news.tdc.fi...
> Randy Brukardt wrote:
>
>> You almost never want redispatching
>
> That's interesting as my experience is the opposite: Most of the calls 
> between primitive methods in my code use redispatching.
>
> My tagged types tend to have a hierarchy of primitive operations, for 
> example an Overall_Method that implements some functionality by a sequence 
> of calls to a Detail_Method. Some derived types override Detail_Method, so 
> the call from Overall_Method to Detail_Method must redispatch. Some other 
> (or the same) derived types override Overall_Method, so it cannot be 
> class-wide.

It seems to me that one or the other of these routines ought to be 
class-wide, the fact that neither can be is a design problem. But YMMV.

The primary reason that you don't (usually) want redispatch is that it is 
hard to guarentee the semantics of a routine if it re-dispatches and thus 
calls routines with unknown semantics. For Ada predefined libraries, we went 
so far as to create a rule that calls do *not* redispatch - A(3.1/3) (You'll 
have to look in the draft RM to see that one, since it was added in response 
to a question on Ada 2005: see 
http://www.adaic.com/standards/1zrm/html/RM-A.html). To quote:

"For a descendant of a language-defined tagged type, the implementation 
shall ensure that each inherited language-defined subprogram behaves as 
described in this International Standard. In particular, overriding a 
language-defined subprogram shall not alter the effect of any inherited 
language-defined subprogram."

In short, don't redispatch in language-defined routines.

Re-dispatching is really only safe semantically if you can guarentee that 
the functionality of any overriding is a superset of that of the base 
operation. But of course there is no way to guarentee that in Ada; even if 
you intend it to be true and write the code with calls to the parent 
routine, raising an exception can cause it to become false (by skipping the 
parent routine).

Of course, sometimes the semantics aren't very firmly defined, and 
redispatching works fine. As I said, YMMV.

                       Randy.