Contents Index Previous Next
12.5.3 Formal Array Types
1
[The class determined for a formal array type
is the class of all array types.]
Syntax
2
formal_array_type_definition
::= array_type_definition
Legality Rules
3
The only form of discrete_subtype_definition
that is allowed within the declaration of a generic formal (constrained)
array subtype is a subtype_mark.
3.a
Reason: The reason is the same as
for forbidding constraints in subtype_indications
(see 12.1).
4
For a formal array
subtype, the actual subtype shall satisfy the following conditions:
5
- The formal array type and the actual array type shall have
the same dimensionality; the formal subtype and the actual subtype shall
be either both constrained or both unconstrained.
6
- For each index position, the index types shall be the same, and
the index subtypes (if unconstrained), or the index ranges (if constrained),
shall statically match (see 4.9.1). {statically
matching (required) [partial]}
7
- The component subtypes of the formal and actual array types
shall statically match. {statically matching (required)
[partial]}
8
- If the formal type has aliased components, then so shall
the actual.
8.a
Ramification: On the other
hand, if the formal's components are not aliased, then the actual's components
can be either aliased or not.
Examples
9
Example of formal
array types:
10
-- given the generic package
11
generic
type Item is private;
type Index is (<>);
type Vector is array (Index range <>) of Item;
type Table is array (Index) of Item;
package P is
...
end P;
12
-- and the types
13
type Mix is array (Color range <>) of Boolean;
type Option is array (Color) of Boolean;
14
-- then Mix can match Vector and Option can match Table
15
package R is new P(Item => Boolean, Index => Color,
Vector => Mix, Table => Option);
16
-- Note that Mix cannot match Table and Option cannot match Vector
Incompatibilities With Ada 83
16.a
{incompatibilities with Ada
83} The check for matching of component subtypes
and index subtypes or index ranges is changed from a run-time check to
a compile-time check. The Ada 83 rule that ``If the component type is
not a scalar type, then the component subtypes shall be either both constrained
or both unconstrained'' is removed, since it is subsumed by static matching.
Likewise, the rules requiring that component types be the same is subsumed.
Contents Index Previous Next Legal