Re: Is this expected behavior or not

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

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3228 bytes --]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:1xg9wka6slgit.1q0leacagdeuv.dlg@40tude.net...
> On Wed, 20 Mar 2013 12:01:25 +0100, J-P. Rosen wrote:
>
>> Le 20/03/2013 11:04, Dmitry A. Kazakov a �crit :
>>>> It is different in that a subtype does NOT inherit operations, it has
>>>> the SAME operations as its type.
>>>
>>> How do you know that they are same? In what sense are they same?
>>>
>>> But they are evidently not same:
>>>
>>>    procedure Foo (X : out Integer) is
>>>    begin
>>>       X := -1;
>>>    end Foo;
>>>
>>> when inherited by Positive changes its behavior.
>
>> They are not inherited! You can call the above Foo with a variable of
>> type Positive; Constraint_Error is raised after the call when converting
>> back. But once again, it is the same operation that is called by Integer
>> and Positive.
>
> See, same operation applied to same value of same type gives different
> result.
>
> This is called UNTYPED.

Sounds right to me; by the rules of your useless definitions, you can 
clearly prove that Ada is untyped. Since Integer and Positive are names for 
the same type, with non-type properties involved. Calling this "untyped" 
makes much more sense than trying to claim some sort of inheritance 
relationship (which is almost always the case, inheritance is almost never 
worth the mental energy expended upon it).

To me, this just demostrates the worthlessness of your definitions when 
applied to Ada. Apparently others feel the same way.

...
> Inheritance as-is composed with a conversion is relatively harmless when
> the constraint is a range. But when the constraint is arbitrary it would
> break almost everything and it does. This is a hard mathematical fact, no
> LRM or ISO has any authority here.

The whole idea of "inheritance" has almost no value in any context. It's 
definitely not worth the energy that people (including) have put into it. A 
model where every type started with a clean slate other than predefined 
operations works just as well.

...
> The definition is independent on any language. I don't redefine the 
> meaning
> of Ada-subtype. I translate Ada's definition into the terms of ADT. In
> these terms Ada-subtype is a proper type.

I disagree that Integer is an "ADT" in the first place. There is nothing 
"abstract" about Integer or any numeric type (even using the English meaning 
of "abstract") -- all of the values and operations are known and defined by 
the type declaration. Calling it an "ADT" seems brain-damaged to me; an ADT 
in Ada is a private type or an interface or an abstract type -- there has to 
be something hidden.

In any case, this discussion has run its course. So long as you cling to a 
useless and different terminlogy, we really can't discuss the interesting 
topics, like the value of Integer'Class. This is a useful idea, but not the 
way you describe it. If you claim that it has something useful to do with 
subtypes, you are already so far off the rails that there is nothing to talk 
about. We're not going to jettison 40 years of Ada education and 
understanding just to adopt a model that makes Dmitry more comfortable! So 
I'm done here.

                                          Randy.