Re: Ada Annoyances

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

On 22/06/2017 12:29, pythoner6@gmail.com wrote:

> What do you mean by "re-dispatch" here? How is it different from the
> dynamic dispatch that happens in Ada with class-wide types?

Re-dispatch is dynamic dispatch when you go through the same virtual 
table twice. Since you are already there = you have determined the 
actual specific type, it does not make sense (and dangerous) to do this 
again.

(I know that there are software patterns based on re-dispatch, they all 
are wrong.)

>> It is controlled by the type, because see above, Ada is properly typed.
>> The dispatch never happens on a tagged type T. It always do on a
>> class-wide type T'Class, which is not tagged. T /= T'Class.
> 
> Yes, this is exactly this (rather crucial) distinction I didn't
> really  understand. Part of it I think was that the word class didn't have the
> right associations in my mind, coming from C++ where a class is just one
> kind of type.

A class rooted in the type T (T'Class) is a new type with values 
corresponding to the values of T and the values of all types derived from T.

The idea of class is to have an object that may hold any value of T or 
of any of its descendants.

Trivially as a type T'Class cannot be T. It has a different set values.

> In Ada it seems that class refers to a type and it's
> descendants, e.g. a class of types.

It is important to see the difference. There is a class T as a set of 
types derived from T. That is not a type, because it is a set of types.

Then there is a proper type with values corresponding to the closure of 
the values of the types from that set. That is the class type (a 
class-wide type in Ada terms).

   class T is a set
   T'Class is a type (to mimic the closure of class T)

A value of T'Class has in Ada as in C++ the same representation as the 
value of some derived type S from the set class T. This allows 
conversion forth and back between T'Class and S. In Ada terms this is 
called "view conversion". In C++ it is simply there.

Confusion between T'Class and T prevents from having classes of scalar 
types with class-wide objects supporting dynamic dispatch. Ada does not 
have this either, but there is nothing that would prevent it to have 
them. In that case Integer'Class object would have different 
representation from Integer because we don't want to keep tag or vptr 
inside Integer. We would put that into Integer'Class and use proper type 
conversion instead of view conversion.

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