Next: Equality Predicates, Up: Predicates [Contents][Index]

### 3.1 Type Predicates

Function: cl-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, `(cl-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. `(cl-typep object t)` is always true. Likewise, the type symbol `nil` stands for nothing at all, and `(cl-typep object nil)` is always false.
- The type symbol `null` represents the symbol `nil`. Thus `(cl-typep object 'null)` is equivalent to `(null object)`.
- The type symbol `atom` represents all objects that are not cons cells. Thus `(cl-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 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 `cl-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 `cl-typep`.

Function: cl-coerce object type

  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 (`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, `cl-coerce` signals an error.

Macro: cl-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 `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-defmacro` except that optional arguments without explicit defaults use `*` instead of `nil` as 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-byte` type specifier could be implemented if desired; this package does not implement `unsigned-byte` by default.

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

Next: Equality Predicates, Up: Predicates [Contents][Index]