II. Notes on Data Structuring * - Cornell University

NOTES ON DATA STRUCTURING 145
The final example shows how the binary forking tree familiar to LISP
programmers may be defined as a recursive data structure.
type list = (atom:sequence character, cons: (car, cdr:list)).
A list which in LISP dot-notation would be expressed
((A. (B. NIL)). NIL)
can be expressed as a value of type list in almost exactly the same way as it is
in LISP:
cons (cons (atom ("A"),
cons (atom ("B"), atom ("NIL"))),
atom ("NIL")
);
where the type transfer to list type is left implicit.
As an example of the processing of a list, we write a function to reverse a
complete tree, so that every "left fork" in it becomes a "right fork" and
vice-versa.
function reverse (l: list): list;
9.1. REPRESENTATION
with l do
(atom:reverse: = 1,
cons:reverse: = cons (reverse (cdr), reverse (car)))
The standard representation of a recursive type is also very similar to
that of a similarly structured non-recursive type, with the exception that each
component specified as belonging to the recursive type itself is represented
by a location containing a pointer to its value, rather than the value itself.
This use of a pointer is motivated by the fact that the component value may
be of arbitrary size; and it is not possible to allocate any fixed amount
of storage to contain it. This is known as the "tree representation", and is
similar to the tree representation of an array or sequence, except that the
branches may grow to arbitrary and varying heights.
An alternative method of representation is the linear sequence or bitstream.
In this representation it is possible to avoid the use of pointers, and place
the values of recursive substructures contiguous with the rest of the infor-
mation, just as they are in the familiar bracketed character representations
of expressions. However instead of using brackets, we can reestablish the
bracketing structure by context, and if necessary by scanning the tag of
union values. This method is usually associated with packed representations
of the other components, and a very significant reduction in storage may be
achieved, at the expense of enforcing serial access to the components of the