Check if object is of type type, where type is a (quoted) type name of the sort used by Common Lisp. For example,
(cl-typep foo 'integer)is equivalent to
The type argument to the above function is either a symbol or a list beginning with a symbol.
tstands for the union of all types.
t)is always true. Likewise, the type symbol
nilstands for nothing at all, and
nil)is always false.
nullrepresents the symbol
'null)is equivalent to
atomrepresents all objects that are not cons cells. Thus
'atom)is equivalent to
realis a synonym for
fixnumis a synonym for
string-charmatch integers in the range from 0 to 255.
)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
)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
This function attempts to convert object to the specified type. If object is already of that type as determined by
cl-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,
cl-coercesignals an error.
This macro defines a new type called name. It is similar to
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
cl-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
cl-defmacroexcept that optional arguments without explicit defaults use
nilas the “default” default. Some examples:(cl-deftype null () '(satisfies null)) ; predefined (cl-deftype list () '(or null cons)) ; predefined (cl-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
unsigned-bytetype specifier could be implemented if desired; this package does not implement
cl-typecase (see Conditionals) and
(see Assertions) macros also use type names. The
cl-merge functions take type-name
arguments to specify the type of sequence to return. See Sequences.