ToC DocOverview CGDoc RelNotes Index PermutedIndex
Allegro CL
Home Previous Up Next Table of Contents Index
  ANSI Common Lisp   4 Types and Classes   4.2 Types

4.2.3 Type Specifiers

Type specifiers can be symbols, classes, or lists. Figure 4.2.3 Type Specifiers lists symbols that are standardized atomic type specifiers, and Figure 4.2.3 Type Specifiers 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.

Standardized Atomic Type Specifiers
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

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.

Standardized Compound Type Specifier Names
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

The next figure show the defined names that can be used as compound type specifier names but that cannot be used as atomic type specifiers.

Standardized Compound-Only Type Specifier Names
and mod satisfies
eql not values
member or

New type specifiers can come into existence in two ways.

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

The next figure shows some defined names relating to types and declarations.

Defined names relating to types and declarations.
coerce defstruct subtypep
declaim deftype the
declare ftype type
defclass locally type-of
define-condition proclaim typep

The next figure 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.3 Type Specifiers  and Figure 4.2.3 Type Specifiers.

Standardized Type Specifier Names
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

Home Previous Up Next Table of Contents Index
© Franz Inc. 1998-2005 - File last updated 6-21-2002