- A type is characterized by a set of values, and a set of primitive
operations which implement the fundamental aspects of its semantics. An
object of a given type is a run-time entity that contains (has) a value of
- Types are grouped into classes of types, reflecting the similarity of
their values and primitive operations. There exist several language-defined
classes of types (see NOTES below). Elementary types are those whose values
are logically indivisible; composite types are those whose values are
composed of component values.
- The elementary types are the scalar types (discrete and real) and the
access types (whose values provide access to objects or subprograms).
Discrete types are either integer types or are defined by enumeration of
their values (enumeration types). Real types are either floating point types
or fixed point types.
- The composite types are the record types, record extensions, array types,
task types, and protected types. A private type or private extension represents
a partial view (see 7.3) of a type, providing support
for data abstraction. A partial view is a composite type.
- Certain composite types (and partial views thereof) have special
components called discriminants whose values affect the presence,
constraints, or initialization of other components. Discriminants can be
thought of as parameters of the type.
- The term subcomponent is used in this International Standard in place of
the term component to indicate either a component, or a component of another
subcomponent. Where other subcomponents are excluded, the term component is
used instead. Similarly, a part of an object or value is used to mean the
whole object or value, or any set of its subcomponents.
- The set of possible values for an object of a given type can be subjected
to a condition that is called a constraint (the case of a null constraint
that specifies no restriction is also included); the rules for which values
satisfy a given kind of constraint are given in 3.5
for range_constraints, 3.6.1 for index_constraints,
and 3.7.1 for discriminant_constraints.
- A subtype of a given type is a combination of the type, a constraint on
values of the type, and certain attributes specific to the subtype. The
given type is called the type of the subtype. Similarly, the associated
constraint is called the constraint of the subtype. The set of values of a
subtype consists of the values of its type that satisfy its constraint. Such
values belong to the subtype.
- A subtype is called an unconstrained subtype if its type has unknown
discriminants, or if its type allows range, index, or discriminant
constraints, but the subtype does not impose such a constraint; otherwise,
the subtype is called a constrained subtype (since it has no unconstrained
(2) Any set of types that is closed under derivation (see
3.4) can be called a ``class'' of types. However, only certain classes
are used in the description of the rules of the language -- generally those
that have their own particular set of primitive operations (see
3.2.3), or that correspond to a set of types that are matched by a given
kind of generic formal type (see 12.5). The following
are examples of ``interesting'' language-defined classes: elementary, scalar,
discrete, enumeration, character, boolean, integer, signed integer, modular,
real, floating point, fixed point, ordinary fixed point, decimal fixed point,
numeric, access, access-to-object, access-to-subprogram, composite, array,
string, (untagged) record, tagged, task, protected, nonlimited. Special
syntax is provided to define types in each of these classes.
These language-defined classes are organized like this:
ordinary fixed point
decimal fixed point
The classes ``numeric'' and ``nonlimited'' represent other
classification dimensions and do not fit into the above strictly
- Type Declarations
- Subtype Declarations
- Classification of Operations
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Page last generated: 95-03-12