Predicates Predicates Equality Predicates
The CL package defines a version of the Common Lisp
(typep foo 'integer)is equivalent to
The type argument to the above function is either a symbol or a list beginning with a symbol.
-p' to the symbol name to form the name of a predicate function for testing the type. (Built-in predicates whose names end in `
p' rather than `
-p' are used when appropriate.)
tstands for the union of all types.
(typep object t)is always true. Likewise, the type symbol
nilstands for nothing at all, and
(typep object nil)is always false.
nullrepresents the symbol
(typep object 'null)is equivalent to
realis a synonym for
fixnumis a synonym for
string-charmatch integers in the range from 0 to 255.
floatp-safepredicate defined by this package rather than
floatp, so it will work correctly even in Emacs versions without floating-point support.
(integer low high)represents all integers between low and high, inclusive. Either bound may be a list of a single integer to specify an exclusive limit, or a
*to specify no limit. The type
(integer * *)is thus equivalent to
numberrepresent numbers of that type falling in a particular range.
notform combinations of types. For example,
(or integer (float 0 *))represents all objects that are integers or non-negative floats.
eqlto any of the following values. For example,
(member 1 2 3 4)is equivalent to
(integer 1 4), and
(member nil)is equivalent to
(satisfies predicate)represent all objects for which predicate returns true when called with that object as an argument.
The following function and macro (not technically predicates) are
typep, it is simply returned. Otherwise, certain types of conversions will be made: If type is any sequence type (
list, etc.) then object will be converted to that type if possible. If type is
character, then strings of length one and symbols with one-character names can be coerced. If type is
float, then integers can be coerced in versions of Emacs that support floats. In all other circumstances,
coercesignals an error.
defmacroin many ways; when name is encountered as a type name, the body forms are evaluated and should return a type specifier that is equivalent to the type. The arglist is a Common Lisp argument list of the sort accepted by
defmacro*. The type specifier `
(name args...)' is expanded by calling the expander with those arguments; the type symbol `
name' is expanded by calling the expander with no arguments. The arglist is processed the same as for
defmacro*except that optional arguments without explicit defaults use
nilas the ``default'' default. Some examples:
(deftype null () '(satisfies null)) ; predefined (deftype list () '(or null cons)) ; predefined (deftype unsigned-byte (&optional bits) (list 'integer 0 (if (eq bits '*) bits (1- (lsh 1 bits))))) (unsigned-byte 8) == (integer 0 255) (unsigned-byte) == (integer 0 *) unsigned-byte == (integer 0 *)
The last example shows how the Common Lisp
type specifier could be implemented if desired; this package does
unsigned-byte by default.
check-type macros also use type
names. See Conditionals. See Assertions. The
merge functions take type-name
arguments to specify the type of sequence to return. See Sequences.