3.8 Record Types
A record 
object is a composite object consisting of named components. The value 
of a record object is a composite value consisting of the values of the 
components. 
 
Syntax
Name Resolution Rules
Legality Rules
This paragraph was 
deleted.
Within a 
type_declaration, 
a 
name that 
denotes a component, protected subprogram, or entry of the type is allowed 
only in the following cases:
 
A 
name 
that denotes any component, protected subprogram, or entry is allowed 
within an 
aspect_specification, 
an operational item, or a representation item that occurs within the 
declaration of the composite type.
 
A 
name 
that denotes a noninherited discriminant is allowed within the declaration 
of the type, but not within the 
discriminant_part. 
If the discriminant is used to define the constraint of a component, 
the bounds of an entry family, or the constraint of the parent subtype 
in a 
derived_type_definition, 
then its name shall appear alone as a 
direct_name 
(not as part of a larger expression or expanded name). A discriminant 
shall not be used to define the constraint of a scalar component.
 
 
Static Semantics
   If a 
record_type_definition 
includes the reserved word 
limited, the type is called an 
explicitly 
limited record type.
 
If the 
component_list 
of a record type is defined by the reserved word 
null and there 
are no discriminants, then the record type has no components and all 
records of the type are 
null records. A 
record_definition 
of 
null record is equivalent to 
record null; end record. 
 
Dynamic Semantics
 Within 
the definition of a composite type, if a 
component_definition 
or 
discrete_subtype_definition 
(see 
9.5.2) includes a 
name 
that denotes a discriminant of the type, or that is an 
attribute_reference 
whose 
prefix 
denotes the current instance of the type, the expression containing the 
name is called 
a 
per-object expression, and the 
constraint 
or 
range being 
defined is called a 
per-object constraint. 
For 
the elaboration of a 
component_definition 
of a 
component_declaration 
or the 
discrete_subtype_definition 
of an 
entry_declaration 
for an entry family (see 
9.5.2), if the component 
subtype is defined by an 
access_definition 
or if the 
constraint 
or 
range of 
the 
subtype_indication 
or 
discrete_subtype_definition 
is not a per-object constraint, then the 
access_definition, 
subtype_indication, 
or 
discrete_subtype_definition 
is elaborated. On the other hand, if the 
constraint 
or 
range is 
a per-object constraint, then the elaboration consists of the evaluation 
of any included expression that is not part of a per-object expression. 
Each such expression is evaluated once unless it is part of a named association 
in a discriminant constraint, in which case it is evaluated once for 
each associated discriminant.
 
   When a per-object constraint 
is elaborated (as part of creating an object), each per-object expression 
of the constraint is evaluated. For other expressions, the values determined 
during the elaboration of the 
component_definition 
or 
entry_declaration 
are used. Any checks associated with the enclosing 
subtype_indication 
or 
discrete_subtype_definition 
are performed, including the subtype compatibility check (see 
3.2.2), 
and the associated subtype is created. 
 
64  The 
default_expression 
of a record component is only evaluated upon the creation of a default-initialized 
object of the record type (presuming the object has the component, if 
it is in a 
variant_part 
— see 
3.3.1).
 
66  If a record type does not have a 
variant_part, 
then the same components are present in all values of the type.
 
67  A record type is limited if it has the 
reserved word 
limited in its definition, or if any of its components 
are limited (see 
7.5).
 
68  
The predefined operations 
of a record type include membership tests, qualification, and explicit 
conversion. If the record type is nonlimited, they also include assignment 
and the predefined equality operators.
 
Examples
Examples of record 
type declarations: 
type Date is
   record
      Day   : Integer range 1 .. 31;
      Month : Month_Name;
      Year  : Integer range 0 .. 4000;
   end record;
type Complex is
   record
      Re : Real := 0.0;
      Im : Real := 0.0;
   end record;
Examples of record 
variables: 
Tomorrow, Yesterday : Date;
A, B, C : Complex;
-- both components of A, B, and C are implicitly initialized to zero 
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe