Re: Merits of re-dispatching [LONG]

[dmitry@elros.cbb-automation.de (Dmitry A. Kazakov)]

On Sat, 16 Feb 2002 12:10 +0000 (GMT Standard Time),
brangdon@cix.co.uk (Dave Harris) wrote:

>dmitry@elros.cbb-automation.de (Dmitry A. Kazakov) wrote (abridged):
>> That there are three types changes nothing. It works pretty well in
>> Ada 95:
>
>That still doesn't capture the full complexity, because although you have 
>Foo you don't have a Call_Foo. The call to Foo from within Call_Foo must 
>be dispatching, because it must dispatch to different places. Given that 
>it can do this, it's simplest to say the call to Foo from within the 
>destructor is dispatching too, in the same way. So there is no 
>non-dispatching call in the C++.
>
>I don't know Ada, but I think it would look like:
>
> type A is ...
> procedure Foo (Object : A) is
> begin
>    Put_Line ("A.Foo");
> end Foo;
> procedure Call_Foo (Object : A) is
> begin
>    Foo( Object );  -- Dispatching, A.Foo or B.Foo called.

One correction, it should be:

Foo (A'Class (Object)); -- Re-dispatch to "native" Foo

> end Foo;
> procedure Finalize (Object : in out A) is
> begin
>    Call_Foo (Object);
>    Foo (Object);
> end Finalize;
>
> type B is new A ...
> procedure Foo (Object : B) is
> begin
>    Put_Line ("B.Foo");
> end Foo;
> procedure Finalize (Object : in out B) is
> begin
>    Call_Foo (Object); 
>    Foo( Object );
>    Finalize (A (Object));
> end Finalize;
>
>This should produce B.Foo B.Foo A.Foo A.Foo.

With my correction it will produce:

B.Foo B.Foo B.Foo A.Foo.
 \         \        \         \
  \         \        \         Foo from A.Finalize -> A.Foo
    \         \       Call_Foo form A.Finalize -> B.Foo (dispatch)
     \        Foo from B.Finalize -> B.Foo
       Call_Foo form B.Finalize -> B.Foo (dispatch)

Alternatively, you could make Call_Foo class wide:

procedure Call_Foo (Object : A'Class) is
begin
    Foo (Object);  -- Dispatching
end Call_Foo;

This is the official way to say that we want to dispatch on A from it
and thus it is defined for all A derivates. [=>it cannot be
overridden] Then a call to Call_Foo form B.Finalize could look as
follows:

   Call_Foo (A'Class (Object)); -- Prepare Object to re-dispatching

The result output will be same. [Ada is a consistent language (:-))]

>The call to Foo from B.Finalize can use exactly the same implementation
>as the call to Foo from A.Call_Foo.

If both are dispatching, but they are not. Only the call from Call_Foo
is dispatching.

>Both end up in B.Foo when the object is of type B. Both are 
>dispatching calls.

That's the point. Why on earth a call to Foo from B.Finalize should
dispatch? The type is known, so there is only one version of Foo to be
called. It can be resolved at compile time and even inlined if
necessary. In Ada it does not dispatch. And that is good. But my point
was that additionally to that there must be no way to enforce
dispatching [like in Call_Foo], because it is unsafe and inefficient.

Regards,
Dmitry Kazakov