Contents Index Previous Next
3.2 Types and Subtypes
Static Semantics
1
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 the type.
1.a
Glossary entry: Each object
has a type. A type has an associated set of values, and a set
of primitive operations which implement the fundamental aspects
of its semantics. Types are grouped into classes. The types of
a given class share a set of primitive operations. Classes
are closed under derivation; that is, if a type is in a class, then all
of its derivatives are in that class.
1.b
Glossary entry: A subtype
is a type together with a constraint, which constrains the values of
the subtype to satisfy a certain condition. The values of a subtype are
a subset of the values of its type.
2
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.
2.a
Glossary entry: A
class is a set of types that is closed under derivation, which means
that if a given type is in the class, then all types derived from that
type are also in the class. The set of types of a class share common
properties, such as their primitive operations.
2.b
Glossary entry: An elementary
type does not have components.
2.c
Glossary entry: A composite
type has components.
2.d
Glossary entry: A scalar
type is either a discrete type or a real type.
2.e
Glossary entry: An access
type has values that designate aliased objects. Access types correspond
to ``pointer types'' or ``reference types'' in some other languages.
2.f
Glossary entry: A discrete
type is either an integer type or an enumeration type. Discrete types
may be used, for example, in case_statements
and as array indices.
2.g
Glossary entry: A real
type has values that are approximations of the real numbers. Floating
point and fixed point types are real types.
2.h
Glossary entry: Integer
types comprise the signed integer types and the modular types. A signed
integer type has a base range that includes both positive and negative
numbers, and has operations that may raise an exception when the result
is outside the base range. A modular type has a base range whose lower
bound is zero, and has operations with ``wraparound'' semantics. Modular
types subsume what are called ``unsigned types'' in some other languages.
2.i
Glossary entry: An enumeration
type is defined by an enumeration of its values, which may be named by
identifiers or character literals.
2.j
Glossary entry: A character
type is an enumeration type whose values include characters.
2.k
Glossary entry: A record
type is a composite type consisting of zero or more named components,
possibly of different types.
2.l
Glossary entry: A record
extension is a type that extends another type by adding additional components.
2.m
Glossary entry: An array
type is a composite type whose components are all of the same type. Components
are selected by indexing.
2.n
Glossary entry: A task
type is a composite type whose values are tasks, which are active entities
that may execute concurrently with other tasks. The top-level task of
a partition is called the environment task.
2.o
Glossary entry: A protected
type is a composite type whose components are protected from concurrent
access by multiple tasks.
2.p
Glossary entry: A private
type is a partial view of a type whose full view is hidden from its clients.
2.q
Glossary entry: A private
extension is like a record extension, except that the components of the
extension part are hidden from its clients.
3
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.
4
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.
4.a
To be honest: The set of
all record types do not form a class (because tagged record types can
have private extensions), though the set of untagged record types do.
In any case, what record types had in common in Ada 83 (component selection)
is now a property of the composite class, since all composite types (other
than array types) can have discriminants. Similarly, the set of all private
types do not form a class (because tagged private types can have record
extensions), though the set of untagged private types do. Nevertheless,
the set of untagged private types is not particularly ``interesting''
-- more interesting is the set of all nonlimited types, since that is
what a generic formal (nonlimited) private type matches.
5
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.
6
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.
6.a
Discussion: The definition
of ``part'' here is designed to simplify rules elsewhere. By design,
the intuitive meaning of ``part'' will convey the correct result to the
casual reader, while this formalistic definition will answer the concern
of the compiler-writer.
6.b
We use the term ``part'' when
talking about the parent part, ancestor part, or extension part of a
type extension. In contexts such as these, the part might represent an
empty set of subcomponents (e.g. in a null record extension, or a nonnull
extension of a null record). We also use ``part'' when specifying rules
such as those that apply to an object with a ``controlled part'' meaning
that it applies if the object as a whole is controlled, or any subcomponent
is.
7
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].
8
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.
8.a
Discussion: We make a strong
distinction between a type and its subtypes. In particular, a type is
not a subtype of itself. There is no constraint associated with
a type (not even a null one), and type-related attributes are distinct
from subtype-specific attributes.
8.b
Discussion: We no longer
use the term "base type." All types were "base types"
anyway in Ada 83, so the term was redundant, and occasionally confusing.
In the RM95 we say simply "the type of the subtype"
instead of "the base type of the subtype."
8.c
Ramification: The value
subset for a subtype might be empty, and need not be a proper subset.
8.d
To be honest: Any name
of a class of types (such as ``discrete'' or ``real''), or other category
of types (such as ``limited'' or ``incomplete'') is also used to qualify
its subtypes, as well as its objects, values, declarations, and definitions,
such as an ``integer type declaration'' or an ``integer value.'' In addition,
if a term such as ``parent subtype'' or ``index subtype'' is defined,
then the corresponding term for the type of the subtype is ``parent type''
or ``index type.''
8.e
Discussion: We use these
corresponding terms without explicitly defining them, when the meaning
is obvious.
9
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
characteristics).
9.a
Discussion: In an earlier
version of Ada 9X, "constrained" meant "has a non-null
constraint." However, we changed to this definition since we kept
having to special case composite non-array/non-discriminated types. It
also corresponds better to the (now obsolescent) attribute 'Constrained.
9.b
For scalar types, ``constrained''
means ``has a non-null constraint''. For composite types, in implementation
terms, ``constrained'' means that the size of all objects of the subtype
is the same, assuming a typical implementation model.
9.c
Class-wide subtypes are always
unconstrained.
10
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.
10.a
Discussion: A
value is a run-time entity with a given type which can be assigned
to an object of an appropriate subtype of the type. An
operation is a program entity that operates on zero or more operands
to produce an effect, or yield a result, or both.
10.b
Ramification: Note that
a type's class depends on the place of the reference -- a private type
is composite outside and possibly elementary inside. It's really the
view that is elementary or composite. Note that although private
types are composite, there are some properties that depend on the corresponding
full view -- for example, parameter passing modes, and the constraint
checks that apply in various places.
10.c
Not every property of types represents
a class. For example, the set of all abstract types does not form a class,
because this set is not closed under derivation.
10.d
The set of limited types forms
a class in the sense that it is closed under derivation, but the more
interesting class, from the point of generic formal type matching, is
the set of all types, limited and nonlimited, since that is what matches
a generic formal ``limited'' private type. Note also that a limited type
can ``become nonlimited'' under certain circumstances, which makes ``limited''
somewhat problematic as a class of types.
11
These language-defined classes are organized
like this:
12
all types
elementary
scalar
discrete
enumeration
character
boolean
other enumeration
integer
signed integer
modular integer
real
floating point
fixed point
ordinary fixed point
decimal fixed point
access
access-to-object
access-to-subprogram
composite
array
string
other array
untagged record
tagged
task
protected
13
The classes ``numeric'' and ``nonlimited''
represent other classification dimensions and do not fit into the above
strictly hierarchical picture.
Wording Changes from Ada 83
13.a
This clause and its subclauses
now precede the clause and subclauses on objects and named numbers, to
cut down on the number of forward references.
13.b
We have dropped the term "base
type" in favor of simply "type" (all types in Ada 83 were
"base types" so it wasn't clear when it was appropriate/necessary
to say "base type"). Given a subtype S of a type T, we call
T the "type of the subtype S."
Contents Index Previous Next Legal