This section enumerates some of the various different primitive types of objects in Zetalisp. The types explained below include symbols, conses, various types of numbers, two kinds of compiled code objects, locatives, arrays, stack groups, and closures.

A symbol (these are sometimes called ``atoms'' or ``atomic symbols'' by other texts) has a print name, a value, a definition, a property list, and a package.

The print name is a string, which may be obtained by the function symbol-name (). This string serves as the printed representation (see ) of the symbol.

Each symbol has a value, which may be any Lisp object. This is the value of the symbol when regarded as a dynamic variable. It is also referred to sometimes as the ``contents of the value cell'', since internally every symbol has a cell called the value cell, which holds the value. It is accessed by the symeval function (), and updated by the set function (). (That is, given a symbol, you use symeval to find out what its value is, and use set to change its value.)

Each symbol has a definition, which may also be any Lisp object. It is also referred to as the ``contents of the function cell'', since internally every symbol has a cell called the function cell, which holds the definition. The definition can be accessed by the fsymeval function (), and updated with fset (), although usually the functions fdefinition and fdefine are employed ().

The property list is a list of an even number of elements; it can be accessed directly by plist (), and updated directly by setplist (), although usually the functions get, putprop, and remprop () are used. The property list is used to associate any number of additional attributes with a symbol--attributes not used frequently enough to deserve their own cells as the value and definition do.

Symbols also have a package cell, which indicates which package of names the symbol belongs to. This is explained further in the section on packages (chapter ) and can be disregarded by the casual user.

The primitive function for creating symbols is make-symbol (), although most symbols are created by read, intern, or fasload (which call make-symbol themselves.)

A cons is an object that cares about two other objects, arbitrarily named the car and the cdr. These objects can be accessed with car and cdr (), and updated with rplaca and rplacd (). The primitive function for creating conses is cons ().

There are several kinds of numbers in Zetalisp. Fixnums represent integers in the range of -2^24 to 2^24-1. Bignums represent integers of arbitrary size, but they are more expensive to use than fixnums because they occupy storage and are slower. The system automatically converts between fixnums and bignums as required. Floats are floating-point numbers. Short floats are another kind of floating-point numbers, with less range and precision, but less computational overhead. Ratios are exact rational numbers that are represented with a numerator and a denominator, which are integers. Complexnums are numbers that have explicitly represented real and imaginary parts, which can be any real numbers of the same type. See for full details of these types and the conversions between them.

A character object is much like a fixnum except that its type is distinguishable. Common Lisp programs use character objects to represent characters. Traditional programs usually use fixnums to represent characters, although they can create an manipulate character objects when they desire. Character objects behave like fixnums when used in arithmetic; only a few operations make any distinction. They do, however, print distinctively. See for more information.

The usual form of compiled, executable code is a Lisp object, called a ``Function Entry Frame'' or ``FEF'' for historical reasons. A FEF contains the code for one function. This is analogous to what Maclisp calls a ``subr pointer''. FEFs are produced by the Lisp Compiler (), and are usually found as the definitions of symbols. The printed representation of a FEF includes its name so that it can be identified.

Another kind of Lisp object that represents executable code is a ``microcode entry''. These are the microcoded primitive functions of the Lisp system, and any user functions compiled into microcode.

About the only useful thing to do with any of these compiled code objects is to apply it to arguments. However, some functions are provided for examining such objects, for user convenience. See arglist (), args-info (), describe (), and disassemble ().

A locative (see ) is a kind of a pointer to a single memory cell anywhere in the system. The contents of this cell can be accessed by cdr (see ) and updated by rplacd (see ).

An array (see ) is a set of cells indexed by a tuple of integer subscripts. The contents of the cells may be accessed and changed individually. There are several types of arrays. Some have cells that may contain any object, while others (numeric arrays) may only contain small positive numbers. Strings are a type of array; the elements are character objects.

A list is not a primitive data type, but rather a data structure made up out of conses and the symbol nil. See .

A predicate is a function that tests for some condition involving its arguments and returns the symbol t if the condition is true, or the symbol nil if it is not true. The following predicates are for testing what data type an object has.

By convention, the names of predicates usually end in the letter `p' (which stands for `predicate').

The following predicates are for testing data types. These predicates return t if the argument is of the type indicated by the name of the function, nil if it is of some other type.

macro-function can be used to test whether a symbol is defined as a macro, but you must be careful because it also returns a non-nil value for certain special forms. See the definition macro-function () to find out how to do this properly.

Other standard type predicates include packagep (see ), random-state-p (see ), hash-table-p (), pathnamep (), streamp () and readtablep (). defstruct can define additional type predicates automatically ().

Data types can be represented symbolically by Lisp objects called type specifiers. A type specifier describes a class of possible Lisp objects; the function typep tells whether a given object matches a given type specifier.

Built-in type specifiers exist for the actual Lisp Machine data types. The user can define additional type specifiers to represent arbitrary classifications of data. Type specifiers can also be combined into specifiers for more complex types.

Some type specifiers are symbols: for example, number, cons, symbol, integer, character, compiled-function, array, vector. Their meanings are mostly obvious, but a table follows below. Type specifiers that are symbols are called simple type specifiers.

Lists can also be type specifiers. They are usually combinations or restrictions of other type specifiers. The car of the list is the key to understanding what it means. An example of a combination is (or array symbol), which matches any array or any symbol. An example of a restriction type is (integer 0 6), which matches only integers between 0 and 6 (inclusive).