Re: about inheritance of subtypes and entities (such as constants) related to a type in the same package

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

On 2018-06-01 01:39 AM, Mehdi Saada wrote:
> The idea was to define for a given (private) type, a series of subtypes with different type invariant, or with or without unknown discriminants (the box), to provide specific variant of the same ADT.

OK, this is a set of related types (though Ada pundits would claim that 
subtype is not a type).

> I know now that is meant to be done through tagged types, and that subtypes are no good for that.

No, you cannot do that with tagged types. These are two different 
type-algebraic operations:

1. subtype creates a new subtype by constraining the base

2. tagged extension creates a new "subtype" by using a set product over 
the original values set

None substitutes another, but you can mix them. They are fully orthogonal.

> But I would have liked a mechanism to generate, why deriving a new type from a parent, these tailored subtypes, with the same same, just like they would have been rewritten.

Deriving creates a new type in a class of types. When you create an Ada 
subtype it is a new member of the class rooted in the base type. When 
you derive from a tagged type T you add a new member to the class rooted 
in T.

What you want is to copy a whole class. It is a second order type 
operation. Ada has two means for that:

1. Type cloning:

    type X is new Y;

This does not work for tagged types and it does not clone subtypes.

2. Generic instantiation.

This works for anything, but imposes severe software design problems.

> But it doesn't take much to see it wasn't a good idea, and that a lot problem would occur... like: what happens when the derived type has constraints or invariants incompatible with subtypes associated with the parent ?

That cannot happen because constraints are inherited. If you need 
another constraint you derive another type.

> I should say "Copying" rather than inheriting. "Copying" constants would fail for the same reason. I/one is better of with converting the constants defined once, for the whole type hierarchy. Though the problem is only with untagged types, tagged private types have class-wide constants.

Both mechanisms copy literals if that is what you meant.

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