Re: 'Class'Class'Class'Class ad libitum

["Alejandro R. Mosteo" <alejandro@mosteo.com>]

On 13/09/16 18:34, Dmitry A. Kazakov wrote:
> On 2016-09-13 18:10, Alejandro R. Mosteo wrote:
>> On 13/09/16 14:37, Dmitry A. Kazakov wrote:
>>> On 13/09/2016 12:43, Alejandro R. Mosteo wrote:
>>>> I get why this is legal:
>>>>
>>>>    type X is tagged null record;
>>>>
>>>>    subtype Y is X'Class;
>>>>
>>>>    subtype Z is X'Class'Class'Class'Class;
>>>>
>>>> But can you think of any legitimate reason to use it besides
>>>> obfuscation?
>>>
>>> Only the latter is wrong. X'Class'Class cannot be same as X'Class.
>>>
>>> X is a set of values with operations on X
>>>
>>> X'Class is a set of values of X and values of all types derived from X
>>>
>>> X'Class'Class should be a set of values of X'Class and values of all
>>> types derived from X'Class. We cannot derive from X'Class in Ada, so
>>> class of X'Class holds only X'Class. But that does not make them same.
>>> Like X is not same as X'Class even if there is no descendants of X.
>>> Class-wide operations of X would be primitive operations of
>>> X'Class'Class.
>>
>> I see that from a strict theoretic POV. However, that's not the
>> interpretation that current Ada grammar does, right?
>
> Semantics you mean. That semantics is wrong. If T'Class'Class is legal,
> I don't know. It should not be otherwise than in the described above sense.
>
>> Actually I arrived at this because I am somewhat wary of the fact that
>> using a subtype like Y in my example hides the fact to the reader that
>> the type is class-wide and hence dispatching by default.
>
> Dispatching is a property of an operation's argument, not of a type. The
> same object may dispatch or not. It should not be reader's concern.
> Dispatching is merely a method of operation implementation, that is by
> composition of the operation body out of multiple bodies of other
> operations selected by the tag. It is a pure implementation detail.

True, but the reader/user needs to make explicit the class-wideness of a 
value if dispatching is desired (and conversely), and this can lead to 
errors. GPS nowadays highlights dispatching calls...

>
>> Furthermore,
>> you can legally write
>>
>> procedure Blah (This : Other_Package.Y); -- or
>> procedure Blah (This : Other_Package.Y'Class);
>>
>> and AFAIK that's totally equivalent but the former is less informative
>> (and alas, shorter to write).
>
> From the original Ada POV the former is better. Initially Ada strove to
> have nominal typing. T'Class notation parts with that, it is structural
> equivalence, which is not that great.

Interesting.

>
>> First time I wrote the later I expected to
>> get an error or warning of the short "subtype is already class-wide".
>
> A good catch by compiler.

That Gnat does not perform ;)