4.2 Types

4.2.1 Data Type Definition

Information about type usage is located in the sections specified in Figure 4–1. Figure 4–7 lists some classes that are particularly relevant to the object system. Figure 9–1 lists the defined condition types.

Section Data Type
Section 4.3 (Classes) Object System types
Section 7.5 (Slots) Object System types
Chapter 7 (Objects) Object System types
Section 7.6 (Generic Functions and Methods) Object System types
Section 9.1 (Condition System Concepts) Condition System types
Chapter 4 (Types and Classes) Miscellaneous types
Chapter 2 (Syntax) All types—read and print syntax
Section 22.1 (The Lisp Printer) All types—print syntax
Section 3.2 (Compilation) All types—compilation issues

Figure 4–1. Cross-References to Data Type Information

4.2.2 Type Relationships

• The types cons, symbol, array, number, character, hash-table, function, readtable, package, pathname, stream, random-state, condition, restart, and any single other type created by defstruct, define-condition, or defclass are pairwise disjoint, except for type relations explicitly established by specifying superclasses in defclass or define-condition or the :include option of destruct.

• Any two types created by defstruct are disjoint unless one is a supertype of the other by virtue of the defstruct :include option.

• Any two distinct classes created by defclass or define-condition are disjoint unless they have a common subclass or one class is a subclass of the other.

• An implementation may be extended to add other subtype relationships between the specified types, as long as they do not violate the type relationships and disjointness requirements specified here. An implementation may define additional types that are subtypes or supertypes of any specified types, as long as each additional type is a subtype of type t and a supertype of type nil and the disjointness requirements are not violated.

At the discretion of the implementation, either standard-object or structure-object might appear in any class precedence list for a system class that does not already specify either standard-object or structure-object. If it does, it must precede the class t and follow all other standardized classes.

4.2.3 Type Specifiers

Type specifiers can be symbols, classes, or lists. Figure 4–2 lists symbols that are standardized atomic type specifiers, and Figure 4–3 lists standardized compound type specifier names. For syntax information, see the dictionary entry for the corresponding type specifier . It is possible to define new type specifiers using defclass, define-condition, defstruct, or deftype.

arithmetic-error	function	simple-condition
array	generic-function	simple-error
atom	hash-table	simple-string
base-char	integer	simple-type-error
base-string	keyword	simple-vector
bignum	list	simple-warning
bit	logical-pathname	single-float
bit-vector	long-float	standard-char
broadcast-stream	method	standard-class
built-in-class	method-combination	standard-generic-function
cell-error	nil	standard-method
character	null	standard-object
class	number	storage-condition
compiled-function	package	stream
complex	package-error	stream-error
concatenated-stream	parse-error	string
condition	pathname	string-stream
cons	print-not-readable	structure-class
control-error	program-error	structure-object
division-by-zero	random-state	style-warning
double-float	ratio	symbol
echo-stream	rational	synonym-stream
end-of-file	reader-error	t
error	readtable	two-way-stream
extended-char	real	type-error
file-error	restart	unbound-slot
file-stream	sequence	unbound-variable
fixnum	serious-condition	undefined-function
float	short-float	unsigned-byte
floating-point-inexact	signed-byte	vector
floating-point-invalid-operation	simple-array	warning
floating-point-overflow	simple-base-string
floating-point-underflow	simple-bit-vector

Figure 4–2. Standardized Atomic Type Specifiers

If a type specifier is a list, the car of the list is a symbol, and the rest of the list is subsidiary type information. Such a type specifier is called a compound type specifier. Except as explicitly stated otherwise, the subsidiary items can be unspecified. The unspecified subsidiary items are indicated by writing *. For example, to completely specify a vector , the type of the elements and the length of the vector must be present.

(vector double-float 100)

The following leaves the length unspecified:

(vector double-float *)

The following leaves the element type unspecified:

(vector * 100)

Suppose that two type specifiers are the same except that the first has a * where the second has a more explicit specification. Then the second denotes a subtype of the type denoted by the first.

If a list has one or more unspecified items at the end, those items can be dropped. If dropping all occurrences of * results in a singleton list, then the parentheses can be dropped as well (the list can be replaced by the symbol in its car ). For example, (vector double-float *) can be abbreviated to (vector double-float), and (vector * *) can be abbreviated to (vector) and then to vector.

and	long-float	simple-array
array	member	simple-base-string
base-string	mod	simple-bit-vector
bit-vector	not	simple-string
complex	or	simple-vector
cons	rational	single-float
double-float	real	string
eql	satisfies	unsigned-byte
float	short-float	values
function	signed-byte	vector
integer

Figure 4–3. Standardized Compound Type Specifier Names

Figure 4–4 show the defined names that can be used as compound type specifier names but that cannot be used as atomic type specifiers.

and	mod	satisfies
eql	not	values
member	or

Figure 4–4. Standardized Compound-Only Type Specifier Names

New type specifiers can come into existence in two ways.

• Defining a structure by using defstruct without using the :type specifier or defining a class by using defclass or define-condition automatically causes the name of the structure or class to be a new type specifier symbol.

• deftype can be used to define derived type specifiers, which act as ‘abbreviations’ for other type specifiers.

A class object can be used as a type specifier . When used this way, it denotes the set of all members of that class.

Figure 4–5 shows some defined names relating to types and declarations.

coerce	defstruct	subtypep
declaim	deftype	the
declare	ftype	type
defclass	locally	type-of
define-condition	proclaim	typep

Figure 4–5. Defined names relating to types and declarations.

Figure 4–6 shows all defined names that are type specifier names, whether for atomic type specifiers or compound type specifiers; this list is the union of the lists in Figure 4–2 and Figure 4–3.

and	extended-char	nil	serious-condition	standard-object
arithmetic-error	file-error	not	short-float	storage-condition
array	file-stream	null	signed-byte	stream
atom	fixnum	number	simple-array	stream-error
base-char	float	or	simple-base-string	string
base-string	floating-point-inexact	package	simple-bit-vector	string-stream
bignum	floating-point-invalid-operation	package-error	simple-condition	structure-class
bit	floating-point-overflow	parse-error	simple-error	structure-object
bit-vector	floating-point-underflow	pathname	simple-string	style-warning
broadcast-stream	function	print-not-readable	simple-type-error	symbol
built-in-class	generic-function	program-error	simple-vector	synonym-stream
cell-error	hash-table	random-state	simple-warning	t
character	integer	ratio	single-float	two-way-stream
class	keyword	rational	standard-char	type-error
compiled-function	list	reader-error	standard-class	unbound-slot
complex	logical-pathname	readtable	standard-generic-function	unbound-variable
concatenated-stream	long-float	real	standard-method	undefined-function
condition	member	restart	unsigned-byte
cons	method	satisfies	values
control-error	method-combination	sequence	vector
division-by-zero	mod	warning
double-float
echo-stream
end-of-file
eql
error

Figure 4–6. Standardized Type Specifier Names