Chapter 13: Language-defined types

The Aldor language defines only those types which are required in specifying what the language does. Most of the types which are usually found in high-level programming languages are delegated to libraries in Aldor. This allows the library designer maximum flexibility in dressing the basic types with desired operations.

The language defined types are listed below. Here, n, m >= 0.

13.1 Type
13.2 (S₁,...,S_n) -> (T₁,...,T_m)
13.3 Tuple T
13.4 Cross(T₁,...,T_n)
13.5 Enumeration(x₁,...,x_n)
13.6 Record(T₁,...,T_n)
13.7 TrailingArray((U₁,...,U_n),(V₁,...,V_m))
13.8 Union(T₁,...,T_n)
13.9 Category
13.10 Join(C₁,...,C_n)
13.11 Boolean
13.12 Literal
13.13 Generator T
13.14 Exit
13.15 Foreign I
13.16 Machine

These types are described in the sections which follow.

13.1 : Type

Type: Type
"Type" is the type of all data type objects, including itself. Sometimes it it not possible to tell whether a value is a type. Unless a value has been explicitly asserted to be a type, then it is not treated as one. In the example below, the parameter "t" of the function "higher" is a type in some possible calls but not in others.
```
#include "aldor.as"

higher(T: Type, f: T->T, t: T): T == f f t;

-- next next 2
n: Integer   == higher(Integer, next,   2);

-- List List Integer
L: BasicType == higher(BasicType, List, Integer);
```

13.2 : **(S₁,..,S_n)->(T₁,..,T_m)**

->: (Tuple Type, Tuple Type) -> Type
``(S₁,..,S_n)->(T₁,..,T_m)'' is the type for functions which have n arguments and produce m results of the given types. The types S_i may be mutually dependent and may have default values. The types T_j may depend on S_i as well as on each other. These are a few examples of function types:

I ==> Integer	A shorthand for these examples.

(I, I) -> ()	No result --- useful for side-effecting functions.
(I, I) -> I	One result --- most common case.
(I, I) -> (I, I)	Two results.
Tuple I -> Tuple I	Any number of arguments and any number of results.

(i: I, n: I) -> I	The arguments may be passed by keyword.
(i: I, n: I == 0) -> I	The arguments may be passed by keyword, and the second one has a default value.

(I, n: I)-> IntegerMod n	The return type depends on an argument value.
(n: I, IntegerMod n)-> I	One argument type depends on another argument value.

13.3 : Tuple T

Tuple: Type -> Type
Tuples provide n-ary, homogenous products. The language allows explicit multiple values of the same type or a "Cross" of values of the same type to be converted to a Tuple. For example, (), (1), (1, 2), and (1,3,7,8) may all be used where a Tuple(Integer) is expected. Both the base Aldor library and the AXIOM library extend Tuple to provide operations to count the elements or extract particular ones:
length: Tuple S -> SingleInteger
element: (Tuple S, SingleInteger) -> S
These operations are named differently to the standard "#" and "apply" to avoid ambiguity between values and singleton tuples. The "element" operation uses 1-based indexing. Tuple values are not updatable.

13.4 : Cross(T₁,...,T_n)

Cross: Tuple Type -> Type
This is the constructor for cross-product types. The language allows explicit multiple values to be converted to a single cross product value and vice versa. Here is an example:
```
-- Conversion of multiple values to a cross product:
ij: Cross(Integer, Integer) := (1, 2);

-- Conversion of a cross product to multiple values:
(i, j) := ij;

-- This gives the same result as  n := i + j.
n := + ij;
```
There are no operations for counting or selecting product components, and product values are not updatable. The products may be cartesian or dependent:
```
Cross(Integer, Integer)          -- cartesian product
Cross(n: Integer, IntegerMod(n)) -- dependent product
```

13.5 : Enumeration(x₁,...,x_n)

Enumeration: Tuple Type -> Type
Enumerations are types consisting of a fixed set of symbolic values. A list of names enclosed in single quotes is a short-hand for a call to Enumeration. For example,
```
Colour == 'red, green, blue';

x: Colour := red
```
One of the common uses of enumerations is for selector functions. For example, in the base Aldor library, the type List(S) exports the following operations:
```
apply: (%, 'first') -> S
set!:  (%, 'first', S) -> S
apply: (%, 'rest') -> %
set!:  (%, 'rest', %) -> %
```
This allows expressions of the form:
```
l.first; l.first := s
l.rest;  l.rest  := l
```
Separate types 'first' and 'rest' are used, rather than one 'first, rest', to allow strong type checking. The precise way in which enumerations work may seem a bit strange at first: the form
```
'red, green, blue'
```
is actually a short-hand for the call
```
Enumeration(red: Type, green: Type, blue: Type)
```
Notice that this has the same form as a typical call to Record or a call to "->" with keyword arguments. This provides enumerations without introducing any extra fundamental ideas into the language.

13.6 : Record(T₁,...,T_n)

Record: Tuple Type -> Type
Records provide the basic updatable structure for aggregate data. Each type argument to Record may be given in any of the following forms:

T or id : T or id : T == v .

A record type Record(T₁,...,T_n) exports the following operations:
bracket: (T₁,...,T_n) -> %
record: (T₁,...,T_n) -> %
explode: % -> (T₁,...,T_n)
dispose!: % -> ()
and, for each argument of the form id : T or id : T == v , the record type also exports the operations:
apply: (%, 'id_i') -> T_i
set!: (%, 'id_i', T_i) -> T_i
The "bracket" and "record" operations have the same function and construct new record values. The "bracket" operation allows records to be constructed with the syntax [1,1], which is nice and concise. More importantly, it allows record types to be used generically --- that is, without disclosing that the heterogeneous aggregate is a record type, as opposed to a table or other structure.

The "record" operation allows documented construction of record values. This is convenient if there are many aggregate types in scope (lists, lists of records, records of lists etc.) and the bracket operation becomes too heavily overloaded for clarity.

The "explode" operation allows record values to be deconstructed into their constitutent parts. This is convenient for use with multiple assignment or passing all the components to a function of an equal number of arguments.

The "dispose!" operation promises that its argument will no longer be referenced, and on certain platforms permits the memory to be reused immediately. It is not necessary to use this function: if you don't, storage will be garbage collected periodically. The choice often boils down to debugability versus speed.

The "apply" and "set!" operations allow the record fields to be extracted and reset. This may be done with either explicit calls to these functions or implicit calls arising from the forms "r.i" or "r.i := 7".

The substitution of the type arguments into the exported operations uses the original form in which the argument is given. As a consequence, record constructors support keyword arguments and arguments with default values.

To be concrete, we give a few examples.

Record(I, DF)
The simplest (and least useful) way to use Record is to call it with simple type expressions, giving neither field names nor default values with the arguments. An example would be Record(Integer, DoubleFloat). In this case no "apply" or "set!" operations are exported, and the behaviour of the record type is very similar to that of a corresponding call to Cross.
bracket: (Integer, DoubleFloat) -> %
record: (Integer, DoubleFloat) -> %
explode: % -> (Integer, DoubleFloat)
dispose!: % -> ()

Record(i: I, x: DF)
The call Record(i: Integer, x: DoubleFloat) provides a record type with the following operations:
bracket: (i: Integer, x: DoubleFloat) -> %
record: (i: Integer, x: DoubleFloat) -> %
explode: % -> (Integer, DoubleFloat)
dispose!: % -> ()
apply: (%, 'i') -> Integer
apply: (%, 'x') -> DoubleFloat
set!: (%, 'i', Integer) -> Integer
set!: (%, 'x', DoubleFloat) -> DoubleFloat

This allows expressions of the form
```
r := [3, 4.0];
r := [i == 3, x == 4.0]
r := [x == 4.0, i == 3]

(vi, vx) := explode r

r.i := 7
r.x := 32.0
```
To be painstakingly correct, the exports are not precisely as shown above. The actual exports are:
bracket: (i: Integer, x: DoubleFloat) -> %
record: (i: Integer, x: DoubleFloat) -> %
explode: % -> (i: Integer, x: DoubleFloat)
dispose!: % -> ()
apply: (%, 'i') -> (i: Integer)
apply: (%, 'x') -> (x: DoubleFloat)
set!: (%, 'i', i: Integer)) -> (i: Integer)
set!: (%, 'x', x: DoubleFloat) -> (x: DoubleFloat)

What is happening is that the exports from the record type all support keyword arguments as a consequence of uniform substitution. This really only useful for the "bracket" and "record" operations, but it is cleaner to be completely uniform.

Record(i:I==7, x:DF==0)
If argument types to Record are given with default values, for example Record(i: Integer == 7, x: DoubleFloat == 0), then the uniform substitution yields the following construction operations:
bracket: (i: Integer == 7, x: DoubleFloat == 0) -> %
record: (i: Integer == 7, x: DoubleFloat == 0) -> %

Now it is no longer necessary to supply all the fields when constructing new values:
```
r := [5];      -- Same as  r := [5, 0]
r := [.01];    -- Same as  r := [7, .01]
r := [];       -- Same as  r := [7, 0]
```

13.7 : TrailingArray((U₁,...,U_n),(V₁,...,V_m))

TrailingArray: (Tuple Type,Tuple Type) -> Type
Trailing arrays are an aggragate data type consisting of two parts; a header, and an array of objects immediately following. The representation for this is a single block of memory, the array immediately following the header. It is up to the user to ensure that accesses to the trailing part of the structure are correct. For example, a polynomial could be represented as: TrailingArray( sz: Integer , (coef: R, deg: NNI)) This would create a data structure looking like:

sz coef deg coef deg coef deg ...

The advantage of this representation is that the object is created by a single allocation, and that there is no overhead for data pointers (as there would be in a representation using a list of records. For example, the domain Record(sz: Integer, tail: PrimArray Record(r: R, deg: NNI)) contains exactly the same information, but looks like:
Usage: TrailingArray( U, V )
U and V are tuples of types, and so take the form `(T₁, T₂, ...)', or simply `T₁' if there is only a single type in the tuple. Assume that U is `(u₁: U₁, u₂: U₂, ...)'

The domain exports the following functions:
The following are equivalent to the exports of Record(U):

apply: (%, 'u_n') -> U_n
set!: (%, 'u_n', U_n) -> U_n
Trailing part access:
apply: (%, SingleInteger, 'v_n') -> V_n
set!: (%, SingleInteger, 'v_n', V_n) -> V_n
Allocation and disposal:
bracket: (SingleInteger, Cross U, Cross V) -> %
trailing: (SingleInteger, Cross U, Cross V) -> %
dispose!: % -> ()
The allocation functions take 3 arguments: a size, and an initial value for both the header and trailing parts. The trailing part argument is ignored at the moment. These have to be filled in by the user, and the initial value of the trailing parts is undefined. Currently the datatype does not support dependent types at all.

13.8 : Union(T₁,...,T_n)

Union: Tuple Type -> Type
The Union constructor provides types which can be used to represent values belonging to any one of several alternative types.

If a function were to return either an integer or a floating point number, then a type such as Union(int: Integer, flo: Float) could be used. This type would then provide the following operations:
bracket: (int: Integer) -> %
bracket: (flo: Float) -> %
union: (int: Integer) -> %
union: (flo: Float) -> %
case: (%, 'int') -> Boolean
case: (%, 'flo') -> Boolean
apply: (%, 'int') -> Integer
apply: (%, 'flo') -> Float
set!: (%, 'int', Integer) -> Integer
set!: (%, 'flo', Float) -> Float
dispose!: % -> ()
That is, for each argument, id : T , the union type exports the following operations:
bracket: (id: T) -> %
union: (id: T) -> %
case: (%, 'id') -> Boolean
apply: (%, 'id') -> T

set!: (%, 'id', T) -> %
Just as with record types, constructors are available both with a generic name ("bracket") and a type-specific name ("union"). These form union values from values belonging to the branch types.

The "case" operation tests whether the union value is in the given branch. The "apply" operation extracts the value and the "set!" operation modifies the value of an existing union.

Example:

import from Union(num: Integer, rec: Record(c: Character, s: String));

-- Generic constructors
u := [3];
u := [[char "c", "hello"]];

-- Specially named constructors
u := union 3;
u := union record(char "c", "hello");

-- Construction using field names
u := [num == 3]
u := union(rec == record(char "c", "bye"));

-- Testing the case of a union.
u case num;   -- This returns false now.
u case rec;   -- This returns true now.

-- Access the union value as a record.
h := u.rec.s;

Using the constructors with keyword arguments is particularly useful when more than one branch of a union has the same type:

MyType(R: Type, E: Type): with {
        fun: Union(coef: R, expon: E) -> %;
} == ...

-- This import causes both union branches to be `Integer'.
import from MyType(Integer, Integer);

fun [coef  == 7];
fun [expon == 7];

13.9 : Category

Category: Type
Often it is desired to work with some specialized collection of types. Each subtype of Type in Aldor is a value which, itself, belongs to the type "Category". Categories allow parameterized constructions to specify the requirements on type-valued parameters. A type satisfies a category if it provides all the required exports. The keyword with is used to form basic Category values and it is possible to test whether a type satisfies a category at evaluation time, using has. For more discussion on categories, see section 7.9

13.10 : Join(C₁,...,C_n)

Join: Tuple Category -> Category
The type "Join(C₁,...,C_n)" is a category which has the union of all the exports of the argument categories C₁, ... , C_n. Conditional exports have their conditions ored.

#include "aldor"
f(x: Integer): Integer == { if x < 0 then x := -x; return x }

Variables and defined constants may not have type Exit, but functions may have Exit as their return type. A function with return type Exit promises to never return to the caller.

error: String -> Exit
Both ``#include "aldor"'' and ``#include "axiom"'' provide this function. Having Exit as the return type allows this function to be used in writing programmer-defined error functions. Note that a call to error will terminate the program. Example:
```
#include "aldor"

import from FormattedOutput;

errDenom(d: T): Exit == 
        error string."The denominator ~a cannot be used."(<< d);

f(n: T, d: T): Ratio T == {
        d > 0 => n/d;
        d < 0 => (-n)/(-d);
        errDenom d;
}
```
(See
section 26.13 for the use of ``~a'' in formatted output.)
Notice again that an expression of type Exit may appear in a value context. A consequence of this is that expressions such as the following are completely legitimate, but odd:
```
#include "aldor"

l: List Integer := [2, 3, 4, if n < 10 then 5 else error "Too big"];

f(): Integer == return { return { return 7 } }
```

13.15 : Foreign I

Foreign: Type

Foreign: Type -> Type
The type "Foreign" allows programs to receive values from or provide values to programs which are not written in Aldor. The result of the function "Foreign" is similar, but uses an interface for a particular language or environment.

To refer to values which are not produced by an Aldor program, a qualified "import" statement such as the following is used:

import { ISQRT: Integer -> Integer } from Foreign Lisp

To provide values to another environment, a qualified "export" statement is used:

export { J0: DoubleFloat -> DoubleFloat } to Foreign C;

The environments which are understood, are:

Builtin: Type
The type "Builtin" can be used as an interface to abstract machine level operations. The Aldor compiler, for instance, generates calls to functions for some of the run-time support. These functions are, themselves, written in Aldor and made available to the abstract machine with export declarations such as these:

export {
        rtCacheMake:  () -> PtrCache;
        rtCacheCheck: (PtrCache, Tuple Ptr) -> (Ptr, Boolean);
        rtCacheAdd:   (PtrCache, Tuple Ptr, Ptr) -> ();
} to Foreign Builtin;

C: Type

C: Literal -> Type
The type "C" is used as an interface to functions written in (or call-compatible with) the C programming language. The type "C filename" is used as an interface to C functions or macros provided by a particular header file. For details, see chapter 19.
Lisp: Type
The type "Lisp" is used as an interface to functions written in Lisp. This is most useful when Aldor programs are compiled to Lisp code, and allows access to all the operations of the underlying Lisp system (see "import" example above).
Fortran: Type
The type "Fortran" is used as an interface to functions written in Fortran. For details, see chapter 32.

13.16 : Machine

Machine: with ...
A number of types and operations upon them are provided by "Machine". This is the basic vocabulary of hardware-oriented data types out of which all data values in Aldor are composed.

The types exported by Machine do not themselves export any operations. Instead, the operations are exported by Machine at the same level as the types. This is an example of what is known as a multi-sorted algebra in the literature on type systems.

Most programs do not make any reference to "Machine" or its exports. In practice, these types and operations are used within low-level libraries to build a set of richer basic types, which themselves provide relevant operations.

The types exported by Machine are described below. The exported operations are listed in section 14.1.
XByte, HInt, SInt, BInt: Type
These are integer types of various sizes. The types XByte, HInt, SInt are unsigned byte, half-precision and single-precision integer types, capable of representing values in at least the ranges 0 to 255, -32767 to 32767 and -2147483647 to 2147483647, respectively. The type BInt provides a ``big'' integer type, which, in principle, may be of any size. In practice, the size will be limited by considerations such as the amount of memory available to a program.
SFlo, DFlo: Type
These are single-precision and double-precision floating point types.
Bool: Type
This type represents the logical values true and false.
Char: Type
This type provides characters for natural language text. These should not be used to store what are logically numbers, as the values may be translated from one character set to another in moving data across platform.
Nil, Arr, Rec, Ptr: Type
These provide the basis for composite data structures. Values of type Nil, Arr, and Rec may be converted to type Ptr as desired.
Word: Type
Values of types SInt, SFlo and Ptr may be converted to this type.
Previous Home Contents Next

Chapter 13: Language-defined types

13.1 : Type

13.2 : (S1,..,Sn)->(T1,..,Tm)

13.3 : Tuple T

13.4 : Cross(T1,...,Tn)

13.5 : Enumeration(x1,...,xn)

13.6 : Record(T1,...,Tn)

13.7 : TrailingArray((U1,...,Un),(V1,...,Vm))

13.8 : Union(T1,...,Tn)

13.9 : Category

13.10 : Join(C1,...,Cn)

13.11 : Boolean

13.12 : Literal

13.13 : Generator T

13.14 : Exit