Re: Is this expected behavior or not

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

On Tue, 19 Mar 2013 22:59:22 +0100, J-P. Rosen wrote:

> Le 19/03/2013 21:45, Dmitry A. Kazakov a �crit :
>>>> Subtype is a type that inherits some operations (interface) of another
>>>> >> type, called "parent type," "base type," "ancestor type" or "supertype."
>>> > 
>>> > This may be the source of the confusion. What you describe is called
>>> > "subtype" in other languages, but this is called "derived type" in Ada.
>>> > An Ada subtype is a completely different beast, that does not correspond
>>> > to this definition.
>> And how is it different?
>> 
> 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.

> Proof: a fundamental feature of OOP is that you can redefine inherited
> operations. You cannot redefine operations of a subtype to be different
> from those of its type.

But they are redefined. The compiler adds conversion to the subtype for
each in-argument and conversion from the subtype for each out-argument.
Which is what happens with Foo above the body of

   procedure Foo (X : out Positive)

is the body of

   procedure Foo (X : out Integer) + constraint check.

> Note also that a subtype is a property of an object; a value has no
> subtype, only a type.

No, subtyping is a relation between two types, denoted as T<:S.

Object has no subtype, it has a type. So does a value.

>Therefore, it would not be possible to dispatch
> according to the subtype, since you would not know which operation to
> use if the controlling operand is a plain value.

It is impossible to dispatch on a specific type anyway. Dispatching happens
only on a class-wide type.

Integer and Positive indeed form a class, but Ada, presently, has no type
corresponding to that class, e.g. Integer'Class. If it had, and if you had
an object of the type Integer'Class, then you could dispatch. Which is BTW,
a highly desired improvement which would for example sort out the mess we
have with string types.

> Now, you can argue that these are all more flaws of Ada - or recognize
> at last that a subtype is not a different type.

Not at all. Ada 83 subtypes are consistent with the type model when they
are considered abstract data types, as they surely are.

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