Skip to main content

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-base-string array member simple-bit-vector

base-string mod simple-string

bit-vector not simple-vector

complex or single-float

cons rational string

double-float real unsigned-byte

eql satisfies values

float short-float vector

function signed-byte

integer simple-array

|

| :- |

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 function simple-array arithmetic-error generic-function simple-base-string array hash-table simple-bit-vector atom integer simple-condition base-char keyword simple-error base-string list simple-string bignum logical-pathname simple-type-error bit long-float simple-vector bit-vector member simple-warning broadcast-stream method single-float built-in-class method-combination standard-char cell-error mod standard-class character nil standard-generic-function class not standard-method compiled-function null standard-object complex number storage-condition concatenated-stream or stream

condition package stream-error cons package-error string

control-error parse-error string-stream division-by-zero pathname structure-class double-float print-not-readable structure-object echo-stream program-error style-warning end-of-file random-state symbol

eql ratio synonym-stream error rational t

extended-char reader-error two-way-stream file-error readtable type-error file-stream real unbound-slot fixnum restart unbound-variable float satisfies undefined-function floating-point-inexact sequence unsigned-byte floating-point-invalid-operation serious-condition values

floating-point-overflow short-float vector

floating-point-underflow signed-byte warning

|

| :- |

Figure 4–6. Standardized Type Specifier Names