Re: Full view of a private partial view cannot be a subtype

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

On 03/12/2017 23:23, Jere wrote:

> Well, I think either form is a bit too polar.  I've always been taught that
> you use the tool that makes the most sense given the context.  If a type
> has an "is a" relationship, you favor extension.  But if it has a "has a"
> relationship, you favor composition.  If the situation is unique enough,
> then you do something outside the norm.

These two are confusing. One is subtyping another is aggregation.

In your "is-a" the right part is a type or a class of types. E.g. X is a 
Integer = the type of X is a subtype of Integer or, alternatively, 
member of Integer'Class.

In your "has-a" the right part is a container, like String has 
Character. The left and right are unrelated types.

Now there is a "has-a" related to subtyping. Ada does not have that. It 
is a supertype. E.g. if you could declare an interface Numeric and hang 
it on an existing type Integer:

    type Number is old Integer; -- (:-))
or
    supertype Number is Integer <wider range, other numbers>;

Numeric has an Integer = Integer is a Numeric.

Then extension is irrelevant to either "is-a" or "has-a" subtyping 
relation. It is an implementation detail regarding representations of 
two related types. You could have "is-a" with, without extension or 
completely abandoning another type representation, but not in Ada. Ada 
glues interface and representation together. That was an unfortunate 
design choice motivated by premature optimization in order to have view 
conversions.

> In this case I wasn't using extension because I thought it was the best
> method.  I was using it because Ada doesn't provide me a good way to
> rename a type as part of the full view.  Normally I would use subtype,
> but I can't do that with a private declaration (I don't want the client
> to have access to the "subtypedness", but I want to leverage it under
> the hood).  Extension was my first stab at it because of the natural
> flow of type declarations in Ada.

Ada's subtype is another method to implement "is-a"/"has-a" 
relationships by borrowing representation and putting constraints. It is 
"is-a" for in-parameters, "has-a" for out-parameters. It is neither 
worse or better than extension, it is different.

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