Re: Ada Annoyances

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 2017-06-23 17:23, raph.amiard@gmail.com wrote:

> Well that's really a strange way to put it:
> 
> 1. In Ada you dispatch via going through the class wide type But if 
> you do, then your call *will* go through a virtual table.
If that is a primitive operation, then it does, if it is a class-wide 
operation it does not.

> 2. In C++ only virtual methods dispatch and go through the virtual
> table. The penalty on the type is exactly the same (by-ref passing and tag)

Same in Ada. Non-primitive operations do not dispatch. Semantically 
there is no difference.

There are operations defined on the whole class ("virtual operations") 
and operations defined on a specific type. The operations defined on the 
whole class are further subdivided into:

1. Dispatching operations implemented in a way that each specific 
instance of the class has a separate operation body. Dispatching is an 
act of selecting that body according to the actual specific type the 
class-wide object holds.

2. Class-wide operations that have one body for all instances of the class.

> 3. The ONLY thing that differs is the granularity of how you choose
> to dispatch or not. In C++, this choice is made by the method's
> implementer. In Ada, it is made at the call-site by every caller.

It is not granularity it is untyped in C++ vs. typed in Ada.

As I said it is quite possible in Ada to declare a type-specific 
operation for a tagged type. That is, an operation defined on this 
concrete type only and undefined on other instances from the class. 
Usually it is used in the package bodies:

package P is
    type T is tagged ...
end P;

package body P is
    procedure Internal (X : in out T) is -- This does not dispatch
    begin
       ...
    end Internal;
end P;

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de