[top]
[prev]
[next]

## Conventions for describing operations

To describe the argument and result types of operations,
we use a notation like procedure signatures. But since most operations
are too general to be described by a true procedure signature, we
extend the notation in several ways.

The argument to an operation can be required to have a type in a particular
class, such as an ordinal type, set type, etc. In this case the formal
specifies a type class instead of a type. For example:

ORD (x: Ordinal): Integer

The formal type `Any` specifies an argument of any type.
A
single operation name can be overloaded, which means that it denotes
more than one operation. In this case, we write a separate signature
for each of the operations. For example:

ABS (x: Integer) : Integer
(x: Float) : Float

The particular operation will be selected so that each actual argument
type is a subtype of the corresponding formal type or a member
of the corresponding formal type class.
The argument to an operation can be an expression denoting a type.
In this case, we write `Type` as the argument type. For example:

BYTESIZE (T: Type): CARDINAL

The result type of an operation can depend on its argument values
(although the result type can always be determined statically). In
this case, the expression for the result type contains the
appropriate arguments.
For example:
FIRST (T: FixedArrayType): IndexType(T)

`IndexType(T)` denotes the index type of the array type `
T` and `IndexType(a)` denotes the index type of the array `
a`. The definitions of `ElemType(T)` and `ElemType(a)`
are similar.

[top]
[prev]
[next]