Ada Conformity Assessment Authority      Home Conformity Assessment   Test Suite ARGAda Standard
Ada Reference Manual (Ada 2022)Legal Information
Contents   Index   References   Search   Previous   Next 

4.3.1 Record Aggregates

In a record_aggregate, a value is specified for each component of the record or record extension value, using either a named or a positional association. 


record_aggregate ::= (record_component_association_list)
record_component_association_list ::= 
    record_component_association {, record_component_association}
  | null record
record_component_association ::= 
    [component_choice_list =>] expression
   | component_choice_list => <>
component_choice_list ::= 
     component_selector_name {'|' component_selector_name}
   | others
A record_component_association is a named component association if it has a component_choice_list; otherwise, it is a positional component association. Any positional component associations shall precede any named component associations. If there is a named association with a component_choice_list of others, it shall come last. 
In the record_component_association_list for a record_aggregate, if there is only one association, it shall be a named association. 

Name Resolution Rules

The expected type for a record_aggregate shall be a single record type or record extension. 
For the record_component_association_list of a record_aggregate, all components of the composite value defined by the aggregate are needed; for the association list of an extension_aggregate, only those components not determined by the ancestor expression or subtype are needed (see 4.3.2). Each component_selector_name in a record_component_association of a record_aggregate or extension_aggregate shall denote a needed component (including possibly a discriminant). Each component_selector_name in a record_component_association of a record_delta_aggregate (see 4.3.4) shall denote a nondiscriminant component of the type of the aggregate.
The expected type for the expression of a record_component_association is the type of the associated component(s); the associated component(s) are as follows: 
For a positional association, the component (including possibly a discriminant) in the corresponding relative position (in the declarative region of the type), counting only the needed components;
For a named association with one or more component_selector_names, the named component(s);
For a named association with the reserved word others, all needed components that are not associated with some previous association. 

Legality Rules

If the type of a record_aggregate is a record extension, then it shall be a descendant of a record type, through one or more record extensions (and no private extensions).
A record_component_association_list shall be null record only if the list occurs in a record_aggregate or extension_aggregate, and there are no components needed for that list.
For a record_aggregate or extension_aggregate, each record_component_association other than an others choice with a <> shall have at least one associated component, and each needed component shall be associated with exactly one record_component_association. For a record_delta_aggregate, each component_selector_name of each component_choice_list shall denote a distinct nondiscriminant component of the type of the aggregate.
  If a record_component_association with an expression has two or more associated components, all of them shall be of the same type, or all of them shall be of anonymous access types whose subtypes statically match. In addition, Legality Rules are enforced separately for each associated component.
For a record_aggregate or extension_aggregate, if a variant_part P is nested within a variant V that is not selected by the discriminant value governing the variant_part enclosing V, then there is no restriction on the discriminant governing P. Otherwise, the value of the discriminant that governs P shall be given by a static expression, or by a nonstatic expression having a constrained static nominal subtype. In this latter case of a nonstatic expression, there shall be exactly one discrete_choice_list of P that covers each value that belongs to the nominal subtype and satisfies the predicates of the subtype, and there shall be at least one such value. 
  A record_component_association for a discriminant without a default_expression shall have an expression rather than <>. 
  A record_component_association of the record_component_association_list of a record_delta_aggregate shall not:
use the box compound delimiter <> rather than an expression;
have an expression of a limited type;
omit the component_choice_list; or
have a component_choice_list that is an others choice. 
  For a record_delta_aggregate, no two component_selector_names shall denote components declared within different variants of the same variant_part.

Dynamic Semantics

The evaluation of a record_aggregate consists of the evaluation of the record_component_association_list.
For the evaluation of a record_component_association_list, any per-object constraints (see 3.8) for components specified in the association list are elaborated and any expressions are evaluated and converted to the subtype of the associated component. Any constraint elaborations and expression evaluations (and conversions) occur in an arbitrary order, except that the expression for a discriminant is evaluated (and converted) prior to the elaboration of any per-object constraint that depends on it, which in turn occurs prior to the evaluation and conversion of the expression for the component with the per-object constraint. If the value of a discriminant that governs a selected variant_part is given by a nonstatic expression, and the evaluation of that expression yields a value that does not belong to the nominal subtype of the expression, then Constraint_Error is raised.
  For a record_component_association with an expression, the expression defines the value for the associated component(s). For a record_component_association with <>, if the component_declaration has a default_expression, that default_expression defines the value for the associated component(s); otherwise, the associated component(s) are initialized by default as for a stand-alone object of the component subtype (see 3.3.1).
The expression of a record_component_association is evaluated (and converted) once for each associated component.
NOTE   By the rules given above, for a record_aggregate with positional associations, expressions specifying discriminant values appear first and in the same order as their corresponding discriminant_specifications, since the known_discriminant_part occurs first in the declaration of the type. 


Example of a record aggregate with positional associations: 
(4, July, 1776)                                     -- see 3.8 
Examples of record aggregates with named associations: 
(Day => 4, Month => July, Year => 1776)
(Month => July, Day => 4, Year => 1776)
(Disk, Closed, Track => 5, Cylinder => 12)          -- see 3.8.1
(Unit => Disk, Status => Closed, Cylinder => 9, Track => 1)
Examples of component associations with several choices: 
(Value => 0, Succ|Pred => new Cell'(0, nullnull)) -- see 3.10.1
   -- The allocator is evaluated twice:
   -- Succ and Pred designate different cells
(Value => 0, Succ|Pred => <>)                       -- see 3.10.1
   -- Succ and Pred will be set to null
Examples of record aggregates for tagged types (see 3.9 and 3.9.1):
Expression'(null record)
Literal'(Value => 0.0)
Painted_Point'(0.0, Pi/2.0, Paint => Red)

Contents   Index   References   Search   Previous   Next 
Ada-Europe Ada 2005 and 2012 Editions sponsored in part by Ada-Europe