OADL Types

Most variables in OADL are dynamically typed - it is valid to store a string in a variable at one point, and then store an integer in it later. Despite this, OADL is a strongly typed language - there are several different types in OADL, and each represents different kinds of values, and the different types allow different kinds of operations on them.

Scalar types

There are 20 "scalar" object types in OADL - "scalar" in that only one value is stored:

Note: On native 64-bit implementations, Int and Float objects are full 32-bit values. Int objects will have an approximate range of ± 2.1e9.

Dynamic types

There are 25 "dynamic" types in OADL - "dynamic" in that they refer to dynamically-allocated memory managed by the OADL machine.

Packed arrays typically are more efficient than heterogeneous arrays, both in space and in execution efficiency. PackInt, PackFloat, PackLong, and PackDouble arrays have full 32- or 64-bit precision since the type information is not stored per-element.

Dynamic values in OADL are implicitly memory-managed. There is no need for an OADL programmer to keep track of which values are no longer in use and then free them. Instead, when OADL detects that there are no longer any references to a compound value, the value is freed. If the value is an Object, and if the Object has a destroy method, then the destroy method will be called at that time. The order in which compound values is freed is non-deterministic, and therefore destroy method calls may occur in any order.

There are some similarities between Object, Dict, and Array values. All contain a group of several other values - the elements. However, there are some key differences:

Note that Array in this table encompasses all array types: PackInt, String, etc.

Access time refers to the typical time to access one of the elements of the compound value. Only Objects allow private elements - elements not accessible outside the class definition of the Object. An Array may only be accessed via (possibly multiple) numeric indexes and an Object may only be accessed via a Public index. Dict and Object variables allow queries of undefined elements - these queries return nil. And, finally, only Dict variables allow assignments to previously undefined values (this adds a new key/value pair into the dictionary if it is not full).

Type descriptors

The type of an OADL value may be queried by an OADL program. Additionally, variables and procedures may have a "type decoration" indicating that they only store / return values of the given type. Finally, the OADL I/O read() intrinsic can accept type descriptors to indicate the type of the items to be read. All of the type names described in this chapter may be used as type descriptors. In addition, array types may have a shape included as part of the descriptor; for example:

var aPak : PackInt[2,3];

The following tree describes the type hierarchy that OADL follows for type compatibility:

Type
  |
  +-------+-------+---    ...
  |       |       |
 Int    Float   Array[*]  ...
                  |
    +-------------+-------------+-------------+---------------+---       ...
    |             |             |             |               |
  List          Array        String        PackInt        PackFloat      ...
    |             |             |             |               |
  List[n]   Array[n,m,...]   String[n] PackInt[n,...]  PackFloat[n,...]  ...
    |             |             |             |               |
  new List()  new Array()    "hello"       [1,2,3]        [1.,2.,3.]     ...

When queried via oadl::typecheck(), each type in this tree will return true for values having the types of each of its children. For example:

    aList = {"one", "two", "three"} // A List

    oadl::typecheck(List, aList) // aList is, in fact, a List
true

    oadl::typecheck(List[3], aList) // aList is, in fact, a List with shape 3
true

    oadl::typecheck(Array, aList) // aList is *not* an Array of any kind
Illegal type

    aPak = [2,3].iterate() // A PackInt array

    oadl::typecheck(PackInt, aPak) // aPak is, in fact, a PackInt
true

    oadl::typecheck(PackInt[2,3], aPak) // aPak is a PackInt with shape [2,3]
true

    oadl::typecheck(Array, aPak) // aPak is not a heterogeneous Array
Illegal type

    // Both aList and aPak are, generically, arrays
    oadl::typecheck(Array[*], aList) && oadl::typecheck(Array[*], aPak)
true

Back to OADL Program Syntax

Continue to Arrays, Lists, and Strings

Return to Introduction