This Annex contains informal descriptions of some
terms used in this International
Standard. The index provides references to more
formal definitions of all of the terms used in this International Standard To
find more formal definitions, look the term up in the index
type. An abstract type is a tagged type
intended for use as an ancestor of other types, but which is not allowed
to have objects of its own.
type has values that designate aliased objects. Access types correspond
to “pointer types” or “reference types” in some
An aliased view
of an object is one that can be designated by an access value. Objects
allocated by allocators are aliased. Objects can also be explicitly declared
as aliased with the reserved word aliased
. The Access attribute
can be used to create an access value designating an aliased object.
An ancestor of a type is the type itself or, in
the case of a type derived from other types, its parent type or one of
its progenitor types or one of their ancestors. Note that ancestor and
descendant are inverse relationships.
An array type
is a composite type whose components are all of the same type. Components
are selected by indexing.
An aspect is a specifiable property of an entity.
An aspect may be specified by an aspect_specification
on the declaration of the entity. Some aspects may be queried via attributes.
An assertion is a boolean expression that appears
in any of the following: a pragma
Assert, a predicate, a precondition, a postcondition, an invariant, a
constraint, or a null exclusion. An assertion is expected to be True
at run time at certain specified places.
(of types). A category of types is a
set of types with one or more common properties, such as primitive operations.
A category of types that is closed under derivation is also known as
type is an enumeration type whose values include characters.
Class (of types).
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.
type may have has
is a piece of text (explicit or implicit) that is an instance of a syntactic
category defined under “Syntax”.
A container is an object that contain other objects
all of the same type, which could be class-wide. Several predefined container
types are provided by the children of package Ada.Containers (see A.18.1).
type supports user-defined assignment and finalization. Objects are always
finalized before being destroyed.
is a language construct that associates a name with (a view of) an entity.
A declaration may appear explicitly
in the program text (an explicit
declaration), or may be supposed
to occur at a given place in the text as a consequence of the semantics
of another construct (an implicit
This paragraph was
declarations contain a definition for a view of an entity.
A view consists of an identification of the entity (the entity of
the view), plus view-specific characteristics that affect the use of
the entity through that view (such as mode of access to an object, formal
parameter names and defaults for a subprogram, or visibility to components
of a type). In most cases, a declaration also contains the definition
for the entity itself (a renaming_declaration
is an example of a declaration that does not define a new entity, but
instead defines a view of an existing entity (see 8.5)).
type is a type defined in terms of one or more
other types given in a derived type definition. The first of those types another
is the parent type of the derived type and any others are progenitor types
. Each class containing the
parent type or a progenitor type
the derived type. The derived type inherits properties such as components
and primitive operations from the parent and progenitors
A type together with the types derived from it (directly or indirectly)
form a derivation class.
A type is a descendant of itself, its parent and
progenitor types, and their ancestors. Note that descendant and ancestor
are inverse relationships.
type is either an integer type or an enumeration type. Discrete types
may be used, for example, in case_statement
and as array indices.
is a parameter for of
a composite type. It can control, for example, the bounds of a component
of the type if the component is that
an array type
. A discriminant
type can be used to pass data to a task of the type upon creation.
The process by which a declaration achieves its
run-time effect is called elaboration. Elaboration is one of the forms
type does not have components.
enumeration type is defined by an enumeration of its values, which may
be named by identifiers or character literals.
The process by which an expression achieves its
run-time effect is called evaluation. Evaluation is one of the forms
represents a kind of exceptional situation; an occurrence of such a situation
(at run time) is called an exception occurrence
an exception is to abandon normal program execution so as
to draw attention to the fact that the corresponding situation has arisen.
Performing some actions in response to the arising
of an exception is called handling
by which a construct achieves its run-time effect is called execution
Execution of a declaration
is also called elaboration
. Execution of an expression is also
A function is a form of subprogram that returns
a result and can be called as part of an expression.
unit is a template for a (nongeneric) program unit; the template can
be parameterized by objects, types, subprograms, and packages. An instance
of a generic unit is created by a generic_instantiation
The rules of the language are enforced when a generic unit is compiled,
using a generic contract model; additional checks are performed upon
instantiation to verify the contract is met. That is, the declaration
of a generic unit represents a contract between the body of the generic
and instances of the generic. Generic units can be used to perform the
role that macros sometimes play in other languages.
type. An incomplete type gives a view
of a type that reveals only some of its properties. The remaining properties
are provided by the full view given elsewhere. Incomplete types can be
used for defining recursive data structures.
container type. An indexable container
type is one that has user-defined behavior for indexing, via the Constant_Indexing
or Variable_Indexing aspects.
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.
type. An interface type is a form of
abstract tagged type which has no components or concrete operations except
possibly null procedures. Interface types are used for composing other
interfaces and tagged types and thereby provide multiple inheritance.
Only an interface type can be used as a progenitor of another type.
A invariant is an assertion that is expected to
be True for all objects of a given private type when viewed from outside
the defining package.
container type. An iterable container
type is one that has user-defined behavior for iteration, via the Default_Iterator
and Iterator_Element aspects.
An iterator is a construct that is used to loop
over the elements of an array or container. Iterators may be user defined,
and may perform arbitrary computations to access elements from a container.
unit is a separately compiled program unit, and is always a package,
subprogram, or generic unit. Library units may have other (logically
nested) library units as children, and may have other program units physically
nested within them.
A root library unit, together
with its children and grandchildren and so on, form a subsystem
type is (a view of)
a type for which copying
(such as in an assignment_statement) the
is not allowed. A nonlimited type is a (view
type for which copying the
An object is
either a constant or a variable. An object contains a value. An object
is created by an object_declaration
or by an allocator
A formal parameter is (a view of) an object. A subcomponent of an object
is an object.
operation. An overriding operation is
one that replaces an inherited primitive operation. Operations may be
marked explicitly as overriding or not overriding.
program units that allow the specification of groups of logically related
entities. Typically, a package contains the declaration of a type (often
a private type or private extension) along with the declarations of primitive
subprograms of the type, which can be called from outside the package,
while their inner workings remain hidden from outside users.
The parent of a derived type is the first type
given in the definition of the derived type. The parent can be almost
any kind of type, including an interface type.
is a part of a program. Each partition consists of a set of library units.
Each partition may run in a separate address space, possibly on a separate
computer. A program may contain just one partition. A distributed program
typically contains multiple partitions, which can execute concurrently.
A postcondition is an assertion that is expected
to be True when a given subprogram returns normally.
A pragma is a
compiler directive. There are language-defined pragmas that give instructions
for optimization, listing control, etc. An implementation may support
additional (implementation-defined) pragmas.
A precondition is an assertion that is expected
to be True when a given subprogram is called.
A predicate is an assertion that is expected to
be True for all objects of a given subtype.
The primitive operations of a type are the operations (such as subprograms)
declared together with the type declaration. They are inherited by other
types in the same class of types. For a tagged type, the primitive subprograms
are dispatching subprograms, providing run-time polymorphism. A dispatching
subprogram may be called with statically tagged operands, in which case
the subprogram body invoked is determined at compile time. Alternatively,
a dispatching subprogram may be called using a dispatching call, in which
case the subprogram body invoked is determined at run time.
private extension is a type that extends another
type, with the additional properties like
a record extension, except that the components of the extension part
hidden from its clients.
type gives a is a
view of a type that reveals only
some of its properties. The remaining properties are provided by the whose
full view given elsewhere. Private types can be
used for defining abstractions that hide unnecessary details is
from their its
A procedure is a form of subprogram that does not
return a result and can only be called by a statement.
A progenitor of a derived type is one of the types
given in the definition of the derived type other than the first. A progenitor
is always an interface type. Interfaces, tasks, and protected types may
also have progenitors.
is a set of partitions
, each of which may execute in a separate
address space, possibly on a separate computer. A partition consists
of a set of library units.
is either a package, a task unit, a protected unit, a protected
entry, a generic unit, or an explicitly declared subprogram other than
an enumeration literal. Certain kinds of program units can be separately
compiled. Alternatively, they can appear physically nested within other
type is a composite type whose components are accessible
only through one of its protected operations which synchronize protected
concurrent access by multiple tasks.
A real type
has values that are approximations of the real numbers. Floating point
and fixed point types are real types.
extension is a type that extends another type by adding additional components.
type is a composite type consisting of zero or more named components,
possibly of different types.
type. A reference type is one that has
user-defined behavior for “.all”, defined by the Implicit_Dereference
is a declaration that does not define a new entity, but instead defines
a view of an existing entity.
type is either a discrete type or a real type.
pool. Each access-to-object type has
an associated storage pool object. The storage for an object created
by an allocator
comes from the storage pool of the type of the allocator.
Some storage pools may be partitioned into subpools in order to support
finer-grained storage management.
A stream is a sequence of elements that can be
used, along with the stream-oriented attributes, to support marshalling
and unmarshalling of values of most types.
A subprogram is a section of a program that can
be executed in various contexts. It is invoked by a subprogram call that
may qualify the effect of the subprogram through the passing of parameters.
There are two forms of subprograms: functions, which return values, and
procedures, which do not.
A subtype is
a type together with optional constraints, null
exclusions, and predicates a constraint or null exclusion
, which constrain constrains
the values of the subtype to satisfy a
The values of a subtype are a subset of the values of its type.
A synchronized entity is one that will work safely
with multiple tasks at one time. A synchronized interface can be an ancestor
of a task or a protected type. Such a task or protected type is called
a synchronized tagged type.
of a tagged type have a run-time type tag, which indicates the specific
type with which the object was originally created. An operand of a class-wide
tagged type can be used in a dispatching call; the tag indicates which
subprogram body to invoke. Nondispatching calls, in which the subprogram
body to invoke is determined at compile time, are also allowed. Tagged
types may be extended with additional components.
A task type
is a composite type used to represent whose
values are tasks, which are
active entities which that
execute concurrently and which can communicate
via queued task entries with other tasks
The top-level task of a partition is called the environment task.
Each object has
a type. A type
has an associated set of values, and a set of primitive
which implement the fundamental aspects of its semantics.
Types are grouped into categories classes
Most language-defined categories of types are also
classes of types 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
view of an entity reveals some or all of the properties of the entity.
A single entity may have multiple views.(See
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe