Next: Equality Predicates, Previous: Predicates, Up: Predicates

### 4.1 Type Predicates

The CL package defines a version of the Common Lisp `typep` predicate.

— Function: typep object type

> Check if object is of type type, where type is a (quoted) type name of the sort used by Common Lisp. For example, `(typep foo 'integer)` is equivalent to `(integerp foo)`.

The type argument to the above function is either a symbol or a list beginning with a symbol.

- If the type name is a symbol, Emacs appends ‘`-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.)
- The type symbol `t` stands for the union of all types. `(typep` object `t)` is always true. Likewise, the type symbol `nil` stands for nothing at all, and `(typep` object `nil)` is always false.
- The type symbol `null` represents the symbol `nil`. Thus `(typep` object `'null)` is equivalent to `(null` object`)`.
- The type symbol `atom` represents all objects that are not cons cells. Thus `(typep` object `'atom)` is equivalent to `(atom` object`)`.
- The type symbol `real` is a synonym for `number`, and `fixnum` is a synonym for `integer`.
- The type symbols `character` and `string-char` match integers in the range from 0 to 255.
- The type symbol `float` uses the `floatp-safe` predicate defined by this package rather than `floatp`, so it will work correctly even in Emacs versions without floating-point support.
- The type list `(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 `integer`.
- Likewise, lists beginning with `float`, `real`, or `number` represent numbers of that type falling in a particular range.
- Lists beginning with `and`, `or`, and `not` form combinations of types. For example, `(or integer (float 0 *))` represents all objects that are integers or non-negative floats.
- Lists beginning with `member` or `member*` represent objects `eql` to any of the following values. For example, `(member 1 2 3 4)` is equivalent to `(integer 1 4)`, and `(member nil)` is equivalent to `null`.
- Lists of the form `(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 related to `typep`.

— Function: coerce object type

> This function attempts to convert object to the specified type. If object is already of that type as determined by `typep`, it is simply returned. Otherwise, certain types of conversions will be made: If type is any sequence type (`string`, `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, `coerce` signals an error.

— Special Form: deftype name arglist forms...

> This macro defines a new type called name. It is similar to `defmacro` in 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 `*` instead of `nil` as 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 `unsigned-byte` type specifier could be implemented if desired; this package does not implement `unsigned-byte` by default.

The `typecase` and `check-type` macros also use type names. See Conditionals. See Assertions. The `map`, `concatenate`, and `merge` functions take type-name arguments to specify the type of sequence to return. See Sequences.