Ada '83 Language Reference Manual
Copyright 1980, 1982, 1983 owned by the United States Government. Direct reproduction and usage requests to the Ada Information Clearinghouse.
This appendix is informative and is not part of the standard definition of
the Ada programming language. Italicized terms in the abbreviated
descriptions below either have glossary entries themselves or are described
in entries for related terms.
- Accept statement.
- See entry.
- Access type.
- A value of an access type (an access value) is either a null
value, or a value that designates an object created by an allocator. The
designated object can be read and updated via the access value. The
definition of an access type specifies the type of the objects designated
by values of the access type. See also collection.
- Actual parameter.
- See parameter.
- The evaluation of an aggregate yields a value of a composite
type. The value is specified by giving the value of each of the
components. Either positional association or named association may be used
to indicate which value is associated with which component.
- The evaluation of an allocator creates an object and returns a
new access value which designates the object.
- Array type.
- A value of an array type consists of components which are all
of the same subtype (and hence, of the same type). Each component is
uniquely distinguished by an index (for a one-dimensional array) or by a
sequence of indices (for a multidimensional array). Each index must be a
value of a discrete type and must lie in the correct index range.
- Assignment is the operation that replaces the current value of
a variable by a new value. An assignment statement specifies a variable on
the left, and on the right, an expression whose value is to be the new
value of the variable.
- The evaluation of an attribute yields a predefined
characteristic of a named entity; some attributes are functions.
- Block statement.
- A block statement is a single statement that may contain
a sequence of statements. It may also include a declarative part, and
exception handlers; their effects are local to the block statement.
- A body defines the execution of a subprogram, package, or task. A
body stub is a form of body that indicates that this execution is defined
in a separately compiled subunit.
- A collection is the entire set of objects created by
evaluation of allocators for an access type.
- Compilation unit.
- A compilation unit is the declaration or the body of a
program unit, presented for compilation as an independent text. It is
optionally preceded by a context clause, naming other compilation units
upon which it depends by means of one more with clauses.
- A component is a value that is a part of a larger value, or an
object that is part of a larger object.
- Composite type.
- A composite type is one whose values have components.
There are two kinds of composite type: array types and record types.
- See object.
- A constraint determines a subset of the values of a type. A
value in that subset satisfies the constraint.
- Context clause.
- See compilation unit.
- A declaration associates an identifier (or some other
notation) with an entity. This association is in effect within a region of
text called the scope of the declaration. Within the scope of a
declaration, there are places where it is possible to use the identifier to
refer to the associated declared entity. At such places the identifier is
said to be a simple name of the entity; the name is said to denote the
- Declarative Part.
- A declarative part is a sequence of declarations. It
may also contain related information such as subprogram bodies and
- See declaration.
- Derived Type.
- A derived type is a type whose operations and values are
replicas of those of an existing type. The existing type is called the
parent type of the derived type.
- See access type, task.
- Direct visibility.
- See visibility.
- Discrete Type.
- A discrete type is a type which has an ordered set of
distinct values. The discrete types are the enumeration and integer types.
Discrete types are used for indexing and iteration, and for choices in case
statements and record variants.
- A discriminant is a distinguished component of an object or
value of a record type. The subtypes of other components, or even their
presence or absence, may depend on the value of the discriminant.
- Discriminant constraint.
- A discriminant constraint on a record type or
private type specifies a value for each discriminant of the type.
- The elaboration of a declaration is the process by which the
declaration achieves its effect (such as creating an object); this process
occurs during program execution.
- An entry is used for communication between tasks. Externally, an
entry is called just as a subprogram is called; its internal behavior is
specified by one or more accept statements specifying the actions to be
performed when the entry is called.
- Enumeration type.
- An enumeration type is a discrete type whose values are
represented by enumeration literals which are given explicitly in the type
declaration. These enumeration literals are either identifiers or
- The evaluation of an expression is the process by which the
value of the expression is computed. This process occurs during program
- An exception is an error situation which may arise during
program execution. To raise an exception is to abandon normal program
execution so as to signal that the error has taken place. An exception
handler is a portion of program text specifying a response to the
exception. Execution of such a program text is called handling the
- Expanded name.
- An expanded name denotes an entity which is declared
immediately within some construct. An expanded name has the form of a
selected component: the prefix denotes the construct (a program unit; or
a block, loop, or accept statement); the selector is the simple name of
- An expression defines the computation of a value.
- Fixed point type.
- See real type.
- Floating point type.
- See real type.
- Formal parameter.
- See parameter.
- See subprogram.
- Generic unit.
- A generic unit is a template either for a set of subprograms
or for a set of packages. A subprogram or package created using the
template is called an instance of the generic unit. A generic
instantiation is the kind of declaration that creates an instance. A
generic unit is written as a subprogram or package but with the
specification prefixed by a generic formal part which may declare generic
formal parameters. A generic formal parameter is either a type, a
subprogram, or an object. A generic unit is one of the kinds of program
- See exception.
- See array type.
- Index constraint.
- An index constraint for an array type specifies the
lower and upper bounds for each index range of the array type.
- Indexed component.
- An indexed component denotes a component in an array.
It is a form of name containing expressions which specify the values of the
indices of the array component. An indexed component may also denote an
entry in a family of entries.
- See generic unit.
- Integer type.
- An integer type is a discrete type whose values represent
all integer numbers within a specific range.
- Lexical element.
- A lexical element is an identifier, a literal, a
delimiter, or a comment.
- Limited type.
- A limited type is a type for which neither assignment nor
the predefined comparison for equality is implicitly declared. All task
types are limited. A private type can be defined to be limited. An
equality operator can be explicitly declared for a limited type.
- A literal represents a value literally, that is, by means of
letters and other characters. A literal is either a numeric literal, an
enumeration literal, a character literal, or a string literal.
- See parameter.
- Model number.
- A model number is an exactly representable value of a real
type. Operations of a real type are defined in terms of operations on the
model numbers of the type. The properties of the model numbers and of
their operations are the minimal properties preserved by all
implementations of the real type.
- A name is a construct that stands for an entity: it is said that
the name denotes the entity, and that the entity is the meaning of the
name. See also declaration, prefix.
- Named association.
- A named association specifies the association of an
item with one or more positions in a list, by naming the positions.
- An object contains a value. A program creates an object either by
elaborating an object declaration or by evaluating an allocator. The
declaration or allocator specifies a type for the object: the object can
only contain values of that type.
- An operation is an elementary action associated with one or
more types. It is either implicitly declared by the declaration of the
type, or it is a subprogram that has a parameter or result of the type.
- An operator is an operation which has one or two operands. A
unary operator is written before an operand; a binary operator is written
between two operands. This notation is a special kind of function call.
An operator can be declared as a function. Many operators are implicitly
declared by the declaration of a type (for example, most type declarations
imply the declaration of the equality operator for values of the type).
- An identifier can have several alternative meanings at a
given point in the program text: this property is called overloading. For
example, an overloaded enumeration literal can be an identifier that
appears in the definitions of two or more enumeration types. The effective
meaning of an overloaded identifier is determined by the context.
Subprograms, aggregates, allocators, and string literals can also be
- A package specifies a group of logically related entities, such
as types, objects of those types, and subprograms with parameters of those
types. It is written as a package declaration and a package body. The
package declaration has a visible part, containing the declarations of all
entities that can be explicitly used outside the package. It may also have
a private part containing structural details that complete the
specification of the visible entities, but which are irrelevant to the user
of the package. The package body contains implementations of subprograms
(and possibly tasks as other packages) that have been specified in the
package declaration. A package is one of the kinds of program unit.
- A parameter is one of the named entities associated with a
subprogram, entry, or generic unit, and used to communicate with the
corresponding subprogram body, accept statement or generic body. A formal
parameter is an identifier used to denote the named entity within the body.
An actual parameter is the particular entity associated with the
corresponding formal parameter by a subprogram call, entry call, or generic
instantiation. The mode of a formal parameter specifies whether the
associated actual parameter supplies a value for the formal parameter, or
the formal supplies a value for the actual parameter, or both. The
association of actual parameters with formal parameters can be specified by
named associations, by positional associations, or by a combination of
- Parent type.
- See derived type.
- Positional association.
- A positional association specifies the association
of an item with a position in a list, by using the same position in the
text to specify the item.
- A pragma conveys information to the compiler.
- A prefix is used as the first part of certain kinds of name. A
prefix is either a function call or a name.
- Private part.
- See package.
- Private type.
- A private type is a type whose structure and set of values
are clearly defined, but not directly available to the user of the type. A
private type is known only by its discriminants (if any) and by the set of
operations defined for it. A private type and its applicable operations
are defined in the visible part of a package, or in a generic formal part.
Assignment, equality, and inequality are also defined for private types,
unless the private type is limited.
- See subprogram.
- A program is composed of a number of compilation units, one of
which is a subprogram called the main program. Execution of the program
consists of execution of the main program, which may invoke subprograms
declared in the other compilation units of the program.
- Program unit.
- A program unit is any one of a generic unit, package,
subprogram, or task unit.
- Qualified expression.
- A qualified expression is an expression preceded by
an indication of its type or subtype. Such qualification is used when, in
its absence, the expression might be ambiguous (for example as a
consequence of overloading).
- Raising an exception.
- See exception.
- A range is a contiguous set of values of a scalar type. A range is
specified by giving the lower and upper bounds for the values. A value in
the range is said to belong to the range.
- Range constraint.
- A range constraint of a type specifies a range, and
thereby determines the subset of the values of the type that belong to the
- Real type.
- A real type is a type whose values represent approximations to
the real numbers. There are two kinds of real type: fixed point types are
specified by absolute error bound; floating point types are specified by a
relative error bound expressed as a number of significant decimal digits.
- Record type.
- A value of a record type consists of components which are
usually of different types or subtypes. For each component of a record
value or record object, the definition of the record type specifies an
identifier that uniquely determines the component within the record.
- Renaming declaration.
- A renaming declaration declares another name for an
- A rendezvous is the interaction that occurs between two
parallel tasks when one task has called an entry of the other task, and a
corresponding accept statement is being executed by the other task on
behalf of the calling task.
- Representation clause.
- A representation clause directs the compiler in the
selection of the mapping of a type, an object, or a task onto features of
the underlying machine that executes a program. In some cases,
representation clauses completely specify the mapping; in other cases,
they provide criteria for choosing a mapping.
- See constraint, subtype.
- Scalar type.
- An object or value of a scalar type does not have components.
A scalar type is either a discrete type or a real type. The values of a
scalar type are ordered.
- See declaration.
- Selected component.
- A selected component is a name consisting of a prefix
and of an identifier called the selector. Selected components are used to
denote record components, entries, and objects designated by access values;
they are also used as expanded names.
- See selected component.
- Simple name.
- See declaration, name.
- A statement specifies one or more actions to be performed
during the execution of a program.
- A subcomponent is either a component, or a component of
- A subprogram is either a procedure or a function. A procedure
specifies a sequence of actions and is invoked by a procedure call
statement. A function specifies a sequence of actions and also returns a
value called the result, and so a function call is an expression. A
subprogram is written as a subprogram declaration, which specifies its
name, formal parameters, and (for a function) its result; and a subprogram
body which specifies the sequence of actions. The subprogram call
specifies the actual parameters that are to be associated with the formal
parameters. A subprogram is one of the kinds of program unit.
- A subtype of a type characterizes a subset of the values of the
type. The subset is determined by a constraint on the type. Each value in
the set of values of a subtype belongs to the subtype and satisfies the
constraint determining the subtype.
- See body.
- A task operates in parallel with other parts of the program. It is
written as a task specification (which specifies the name of the task and
the names and formal parameters of its entries), and a task body which
defines its execution. A task unit is one of the kinds of program unit. A
task type is a type that permits the subsequent declaration of any number
of similar tasks of the type. A value of a task type is said to designate
- A type characterizes both a set of values, and a set of operations
applicable to those values. A type definition is a language construct that
defines a type. A particular type is either an access type, an array type,
a private type, a record type, a scalar type, or a task type.
- Use clause.
- A use clause achieves direct visibility of declarations that
appear in the visible parts of named packages.
- See object.
- Variant part.
- A variant part of a record specifies alternative record
components, depending on a discriminant of the record. Each value of the
discriminant establishes a particular alternative of the variant part.
- At a given point in a program text, the declaration of an
entity with a certain identifier is said to be visible if the entity is an
acceptable meaning for an occurrence at that point of the identifier. The
declaration is visible by selection at the place of the selector in a
selected component or at the place of the name in a named association.
Otherwise, the declaration is directly visible, that is, if the identifier
alone has that meaning.
- Visible part.
- See package.
- With clause.
- See compilation unit.
Address any questions or comments to