# 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.

    Last modified on Wed Apr  3 09:39:09 PST 1996 by heydon
         modified on Fri Apr 15 15:24:37 PDT 1994 by kalsow