Next: Equality Predicates, Previous: Circular Objects, Up: Lisp Data Types [Contents][Index]

### 2.6 Type Predicates

The Emacs Lisp interpreter itself does not perform type checking on the actual arguments passed to functions when they are called. It could not do so, since function arguments in Lisp do not have declared data types, as they do in other programming languages. It is therefore up to the individual function to test whether each actual argument belongs to a type that the function can use.

All built-in functions do check the types of their actual arguments when appropriate, and signal a `wrong-type-argument` error if an argument is of the wrong type. For example, here is what happens if you pass an argument to `+` that it cannot handle:

    (+ 2 'a)
         error→ Wrong type argument: number-or-marker-p, a

If you want your program to handle different types differently, you must do explicit type checking. The most common way to check the type of an object is to call a type predicate function. Emacs has a type predicate for each type, as well as some predicates for combinations of types.

A type predicate function takes one argument; it returns `t` if the argument belongs to the appropriate type, and `nil` otherwise. Following a general Lisp convention for predicate functions, most type predicates’ names end with ‘`p`’.

Here is an example which uses the predicates `listp` to check for a list and `symbolp` to check for a symbol.

    (defun add-on (x)
      (cond ((symbolp x)
             ;; If X is a symbol, put it on LIST.
             (setq list (cons x list)))
            ((listp x)
             ;; If X is a list, add its elements to LIST.
             (setq list (append x list)))
            (t
             ;; We handle only symbols and lists.
             (error "Invalid argument %s in add-on" x))))

Here is a table of predefined type predicates, in alphabetical order, with references to further information.

`atom`

  See atom.

`arrayp`

  See arrayp.

`bool-vector-p`

  See bool-vector-p.

`bufferp`

  See bufferp.

`byte-code-function-p`

  See byte-code-function-p.

`case-table-p`

  See case-table-p.

`char-or-string-p`

  See char-or-string-p.

`char-table-p`

  See char-table-p.

`commandp`

  See commandp.

`consp`

  See consp.

`custom-variable-p`

  See custom-variable-p.

`floatp`

  See floatp.

`fontp`

  See Low-Level Font.

`frame-configuration-p`

  See frame-configuration-p.

`frame-live-p`

  See frame-live-p.

`framep`

  See framep.

`functionp`

  See functionp.

`hash-table-p`

  See hash-table-p.

`integer-or-marker-p`

  See integer-or-marker-p.

`integerp`

  See integerp.

`keymapp`

  See keymapp.

`keywordp`

  See Constant Variables.

`listp`

  See listp.

`markerp`

  See markerp.

`wholenump`

  See wholenump.

`nlistp`

  See nlistp.

`numberp`

  See numberp.

`number-or-marker-p`

  See number-or-marker-p.

`overlayp`

  See overlayp.

`processp`

  See processp.

`sequencep`

  See sequencep.

`stringp`

  See stringp.

`subrp`

  See subrp.

`symbolp`

  See symbolp.

`syntax-table-p`

  See syntax-table-p.

`vectorp`

  See vectorp.

`window-configuration-p`

  See window-configuration-p.

`window-live-p`

  See window-live-p.

`windowp`

  See windowp.

`booleanp`

  See booleanp.

`string-or-null-p`

  See string-or-null-p.

The most general way to check the type of an object is to call the function `type-of`. Recall that each object belongs to one and only one primitive type; `type-of` tells you which one (see Lisp Data Types). But `type-of` knows nothing about non-primitive types. In most cases, it is more convenient to use type predicates than `type-of`.

Function: type-of object

  This function returns a symbol naming the primitive type of object. The value is one of the symbols `bool-vector`, `buffer`, `char-table`, `compiled-function`, `cons`, `finalizer`, `float`, `font-entity`, `font-object`, `font-spec`, `frame`, `hash-table`, `integer`, `marker`, `overlay`, `process`, `string`, `subr`, `symbol`, `vector`, `window`, or `window-configuration`.

      (type-of 1)
           ⇒ integer

      (type-of 'nil)
           ⇒ symbol
      (type-of '())    ; () is nil.
           ⇒ symbol
      (type-of '(x))
           ⇒ cons

Next: Equality Predicates, Previous: Circular Objects, Up: Lisp Data Types [Contents][Index]