12.5 Formal Types
{
AI95-00442-01}
[A generic formal subtype can be used to pass to a generic unit a subtype
whose type is in a certain category of types.]
Reason: We considered having intermediate
syntactic categories
formal_integer_type_definition,
formal_real_type_definition, and
formal_fixed_point_definition,
to be more uniform with the syntax rules for non-generic-formal types.
However, that would make the rules for formal types slightly more complicated,
and it would cause confusion, since
formal_discrete_type_definition
would not fit into the scheme very well.
Syntax
Legality Rules
For
a generic formal subtype, the actual shall be a
subtype_mark;
it denotes the
(generic) actual subtype.
Ramification: When we say simply “formal”
or “actual” (for a generic formal that denotes a subtype)
we're talking about the subtype, not the type, since a name that denotes
a
formal_type_declaration
denotes a subtype, and the corresponding actual also denotes a subtype.
Static Semantics
Ramification: A subtype (other than the
first subtype) of a generic formal type is not a generic formal subtype.
Reason: This rule is clearer with the
flat syntax rule for
formal_type_definition
given above. Adding
formal_integer_type_definition
and others would make this rule harder to state clearly.
{
AI95-00442-01}
We use “category’ rather than “class” above,
because the requirement that classes are closed under derivation is not
important here. Moreover, there are interesting categories that are not
closed under derivation. For instance, limited and interface are categories
that do not form classes.
Legality Rules
{
AI95-00442-01}
The actual type shall be in the category determined for the formal.
Ramification: {
AI95-00442-01}
For example, if the category determined for the formal is the category
of all discrete types, then the actual has to be discrete.
{
AI95-00442-01}
Note that this rule does not require the actual to belong to every category
to which the formal belongs. For example, formal private types are in
the category of composite types, but the actual need not be composite.
Furthermore, one can imagine an infinite number of categories that are
just arbitrary sets of types (even though we don't give them names, since
they are uninteresting). We don't want this rule to apply to
those
categories.
{
AI95-00114-01}
{
AI95-00442-01}
“Limited” is not an “interesting” category, but
“nonlimited” is; it is legal to pass a nonlimited type to
a limited formal type, but not the other way around. The reserved word
limited really represents a category containing both limited and
nonlimited types. “Private” is not a category for this purpose;
a generic formal private type accepts both private and nonprivate actual
types.
{
AI95-00442-01}
It is legal to pass a class-wide subtype as the actual if it is in the
right category, so long as the formal has unknown discriminants.
{
AI12-0205-1}
The
default_subtype_mark,
if any, shall denote a subtype which is allowed as an actual subtype
for the formal type.
Static Semantics
{
8652/0037}
{
AI95-00043-01}
{
AI95-00233-01}
{
AI95-00442-01}
{
AI05-0029-1}
{
AI12-0413-1}
[The formal type also belongs to each category that contains the determined
category.] The primitive subprograms of the type are as for any type
in the determined category. For a formal type other than a formal derived
type, these are the predefined operators of the type. For an elementary
formal type, the predefined operators are implicitly declared immediately
after the declaration of the formal type. For a composite formal type,
the predefined operators are implicitly declared either immediately after
the declaration of the formal type, or later immediately within the declarative
region in which the type is declared according to the rules of
7.3.1.
In an instance, the copy of such an implicit declaration declares a view
of the predefined operator of the actual type, even if this operator
has been overridden for the actual type and even if it is never declared
for the actual type, unless the actual type is an untagged record type,
in which case it declares a view of the primitive (equality) operator.
[The rules specific to formal derived types are given in
12.5.1.]
Ramification: {
AI95-00442-01}
All properties of the type are as for any type in the category. Some
examples: The primitive operations available are as defined by the language
for each category. The form of
constraint
applicable to a formal type in a
subtype_indication
depends on the category of the type as for a nonformal type. The formal
type is tagged if and only if it is declared as a tagged private type,
or as a type derived from a (visibly) tagged type. (Note that the actual
type might be tagged even if the formal type is not.)
{
AI12-0413-1}
If the primitive equality operator of the (actual) untagged record type
is declared abstract, then Program_Error will be raised if the equality
operator of the formal type is in fact invoked within an instance of
a generic body (see
4.5.2). If the operator
is invoked within an instance of the generic spec, the instance is illegal.
Reason: {
AI05-0029-1}
The somewhat cryptic phrase “even if it is never declared”
is intended to deal with the following oddity:
package Q is
type T is limited private;
private
type T is range 1 .. 10;
end Q;
generic
type A is array (Positive range <>) of T;
package Q.G is
A1, A2 : A (1 .. 1);
private
B : Boolean := A1 = A2;
end Q.G;
with Q.G;
package R is
type C is array (Positive range <>) of Q.T;
package I is new Q.G (C); -- Where is the predefined "=" for C?
end R;
An "=" is available for the formal
type A in the private part of Q.G. However, no "=" operator
is ever declared for type C, because its component type Q.T is limited.
Still, in the instance I the name "=" declares a view of the
"=" for C which exists-but-is-never-declared.
NOTE 1 Generic formal types, like
all types, are not named. Instead, a
name
can denote a generic formal subtype. Within a generic unit, a generic
formal type is considered as being distinct from all other (formal or
nonformal) types.
NOTE 2 A
discriminant_part
is allowed only for certain kinds of types, and therefore only for certain
kinds of generic formal types. See
3.7.
Examples
Examples of generic
formal types:
type Item is private;
type Buffer(Length : Natural) is limited private;
type Enum is (<>);
type Int is range <>;
type Angle is delta <>;
type Mass is digits <>;
type Table is array (Enum) of Item;
Example of a generic
formal part declaring a formal integer type:
generic
type Rank is range <>;
First : Rank := Rank'First;
Second : Rank := First + 1; -- the operator "+" of the type Rank
Wording Changes from Ada 83
RM83 has separate sections “Generic Formal
Xs” and “Matching Rules for Formal Xs” (for various
X's) with most of the text redundant between the two. We have combined
the two in order to reduce the redundancy. In RM83, there is no “Matching
Rules for Formal Types” section; nor is there a “Generic
Formal Y Types” section (for Y = Private, Scalar, Array, and Access).
This causes, for example, the duplication across all the “Matching
Rules for Y Types” sections of the rule that the actual passed
to a formal type shall be a subtype; the new organization avoids that
problem.
The matching rules are stated more concisely.
We no longer consider the multiplying operators
that deliver a result of type universal_fixed to be predefined
for the various types; there is only one of each in package Standard.
Therefore, we need not mention them here as RM83 had to.
Wording Changes from Ada 95
{
8652/0037}
{
AI95-00043-01}
{
AI95-00233-01}
Corrigendum 1 corrected the wording to properly define the location where
operators are defined for formal array types. The wording here was inconsistent
with that in
7.3.1, “
Private
Operations”. For the Amendment, this wording was corrected
again, because it didn't reflect the Corrigendum 1 revisions in
7.3.1.
{
AI95-00442-01}
We use “determines a category” rather than class, since not
all interesting properties form a class.
Extensions to Ada 2005
Wording Changes from Ada 2005
{
AI05-0029-1}
Correction: Updated the wording to acknowledge the possibility
of operations that are never declared for an actual type but still can
be used inside of a generic unit.
{
AI05-0213-1}
{
AI05-0299-1}
Formal incomplete types are added; these are documented as an extension
in the next subclause.
Inconsistencies With Ada 2012
{
AI12-0413-1}
Correction: Updated the wording to clarify
that predefined record equality never reemerges in a generic instantiation.
This model was presumed by
4.5.2, but the
wording wasn't right for untagged record types with user-defined equality.
Therefore, an implementation that strictly implemented the Ada 2012 wording
would call the predefined equality for an actual type that is an untagged
record type with a user-defined equality, while Ada 2022 implementations
would call the primitive (user-defined) equality. This could change the
runtime behavior in rare cases.
Extensions to Ada 2012
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
