Info Catalog elisp: Circular Objects elisp: Lisp Data Types elisp: Equality Predicates

elisp: Type Predicates

 
 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’
      atom List-related Predicates.
 
 ‘arrayp’
      arrayp Array Functions.
 
 ‘bool-vector-p’
      bool-vector-p Bool-Vectors.
 
 ‘bufferp’
      bufferp Buffer Basics.
 
 ‘byte-code-function-p’
      byte-code-function-p Byte-Code Type.
 
 ‘case-table-p’
      case-table-p Case Tables.
 
 ‘char-or-string-p’
      char-or-string-p Predicates for Strings.
 
 ‘char-table-p’
      char-table-p Char-Tables.
 
 ‘commandp’
      commandp Interactive Call.
 
 ‘consp’
      consp List-related Predicates.
 
 ‘custom-variable-p’
      custom-variable-p Variable Definitions.
 
 ‘floatp’
      floatp Predicates on Numbers.
 
 ‘fontp’
      Low-Level Font.
 
 ‘frame-configuration-p’
      frame-configuration-p Frame Configurations.
 
 ‘frame-live-p’
      frame-live-p Deleting Frames.
 
 ‘framep’
      framep Frames.
 
 ‘functionp’
      functionp Functions.
 
 ‘hash-table-p’
      hash-table-p Other Hash.
 
 ‘integer-or-marker-p’
      integer-or-marker-p Predicates on Markers.
 
 ‘integerp’
      integerp Predicates on Numbers.
 
 ‘keymapp’
      keymapp Creating Keymaps.
 
 ‘keywordp’
      Constant Variables.
 
 ‘listp’
      listp List-related Predicates.
 
 ‘markerp’
      markerp Predicates on Markers.
 
 ‘wholenump’
      wholenump Predicates on Numbers.
 
 ‘nlistp’
      nlistp List-related Predicates.
 
 ‘numberp’
      numberp Predicates on Numbers.
 
 ‘number-or-marker-p’
      number-or-marker-p Predicates on Markers.
 
 ‘overlayp’
      overlayp Overlays.
 
 ‘processp’
      processp Processes.
 
 ‘sequencep’
      sequencep Sequence Functions.
 
 ‘stringp’
      stringp Predicates for Strings.
 
 ‘subrp’
      subrp Function Cells.
 
 ‘symbolp’
      symbolp Symbols.
 
 ‘syntax-table-p’
      syntax-table-p Syntax Tables.
 
 ‘vectorp’
      vectorp Vectors.
 
 ‘window-configuration-p’
      window-configuration-p Window Configurations.
 
 ‘window-live-p’
      window-live-p Deleting Windows.
 
 ‘windowp’
      windowp Basic Windows.
 
 ‘booleanp’
      booleanp nil and t.
 
 ‘string-or-null-p’
      string-or-null-p Predicates for Strings.
 
    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 (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
 

Info Catalog elisp: Circular Objects elisp: Lisp Data Types elisp: Equality Predicates