Freeware (IRIX)  »  Info Pages
find in page

elisp : Type Predicates

table of contents

  Introduction
  Coding Conventions
  Lisp Data Types
  Numbers
  Strings and Characters
  Lists
  Sequences Arrays Vectors
  Hash Tables
  Symbols
  Evaluation
  Control Structures
  Variables
  Functions
  Macros
  Customization
  Loading
  Byte Compilation
  Advising Functions
  Debugging
  Read and Print
  Minibuffers
  Command Loop
  Keymaps
  Modes
  Documentation
  Files
  Backups and Auto-Saving
  Buffers
  Windows
  Frames
  Positions
  Markers
  Text
  Non-ASCII Characters
  Searching and Matching
  Syntax Tables
  Abbrevs
  Processes
  Display
  Calendar
  System Interface
  Antinews
  GNU Free Documentation License
  GPL
  Tips
  GNU Emacs Internals
  Standard Errors
  Standard Buffer-Local Variables
  Standard Keymaps
  Standard Hooks
  Index
  New Symbols
  Caveats
  Lisp History
  Conventions
  Acknowledgements
  Some Terms
  nil and t
  Evaluation Notation
  Printing Notation
  Error Messages
  Buffer Text Notation
  Format of Descriptions
  Coding Conventions
  Compilation Tips
  Documentation Tips
  Comment Tips
  Library Headers
  A Sample Function Description
  A Sample Variable Description
  Printed Representation
  Comments
  Programming Types
  Editing Types
  Type Predicates
  Equality Predicates
  Integer Type
  Floating Point Type
  Character Type
  Sequence Type
  Cons Cell Type
  Array Type
  String Type
  Vector Type
  Symbol Type
  Function Type
  Macro Type
  Primitive Function Type
  Byte-Code Type
  Autoload Type
  Dotted Pair Notation
  Association List Type
  Buffer Type
  Window Type
  Window Configuration Type
  Marker Type
  Process Type
  Stream Type
  Keymap Type
  Overlay Type
  Integer Basics
  Float Basics
  Predicates on Numbers
  Comparison of Numbers
  Arithmetic Operations
  Bitwise Operations
  Numeric Conversions
  Math Functions
  Random Numbers
  String Basics
  Predicates for Strings
  Creating Strings
  Text Comparison
  String Conversion
  Formatting Strings
  Case Conversion
  Cons Cells
  Lists as Boxes
  List-related Predicates
  List Elements
  Building Lists
  Modifying Lists
  Sets And Lists
  Association Lists
  Setcar
  Setcdr
  Rearrangement
  Sequence Functions
  Arrays
  Array Functions
  Vectors
  Symbol Components
  Definitions
  Creating Symbols
  Property Lists
  Intro Eval
  Eval
  Forms
  Quoting
  Self-Evaluating Forms
  Symbol Forms
  Classifying Lists
  Function Forms
  Macro Forms
  Special Forms
  Autoloading
  Sequencing
  Conditionals
  Combining Conditions
  Iteration
  Nonlocal Exits
  Catch and Throw
  Examples of Catch
  Errors
  Cleanups
  Signaling Errors
  Processing of Errors
  Handling Errors
  Error Symbols
  Global Variables
  Constant Variables
  Local Variables
  Void Variables
  Defining Variables
  Accessing Variables
  Setting Variables
  Variable Scoping
  Buffer-Local Variables
  Scope
  Extent
  Impl of Scope
  Using Scoping
  Intro to Buffer-Local
  Creating Buffer-Local
  Default Value
  What Is a Function
  Lambda Expressions
  Function Names
  Defining Functions
  Calling Functions
  Mapping Functions
  Anonymous Functions
  Function Cells
  Related Topics
  Lambda Components
  Simple Lambda
  Argument List
  Function Documentation
  Simple Macro
  Expansion
  Compiling Macros
  Defining Macros
  Backquote
  Problems with Macros
  How Programs Do Loading
  Autoload
  Named Features
  Repeated Loading
  Compilation Functions
  Disassembly
  Simple Advice
  Defining Advice
  Computed Advice
  Activation of Advice
  Enabling Advice
  Preactivation
  Argument Access in Advice
  Subr Arguments
  Combined Definition
  Debugger
  Syntax Errors
  Compilation Errors
  Edebug
  Error Debugging
  Function Debugging
  Explicit Debug
  Using Debugger
  Debugger Commands
  Invoking the Debugger
  Internals of Debugger
  Excess Open
  Excess Close
  Streams Intro
  Input Streams
  Input Functions
  Output Streams
  Output Functions
  Intro to Minibuffers
  Text from Minibuffer
  Object from Minibuffer
  Completion
  Yes-or-No Queries
  Minibuffer Misc
  Basic Completion
  Minibuffer Completion
  Completion Commands
  High-Level Completion
  Reading File Names
  Programmed Completion
  Command Overview
  Defining Commands
  Interactive Call
  Command Loop Info
  Input Events
  Reading Input
  Waiting
  Quitting
  Prefix Command Arguments
  Recursive Editing
  Disabling Commands
  Command History
  Keyboard Macros
  Using Interactive
  Interactive Codes
  Interactive Examples
  Keymap Terminology
  Format of Keymaps
  Creating Keymaps
  Inheritance and Keymaps
  Prefix Keys
  Menu Keymaps
  Active Keymaps
  Key Lookup
  Functions for Key Lookup
  Changing Key Bindings
  Key Binding Commands
  Scanning Keymaps
  Major Modes
  Minor Modes
  Mode Line Format
  Hooks
  Major Mode Conventions
  Example Major Modes
  Auto Major Mode
  Mode Help
  Minor Mode Conventions
  Keymaps and Minor Modes
  Mode Line Data
  Mode Line Variables
  %-Constructs
  Documentation Basics
  Accessing Documentation
  Keys in Documentation
  Describing Characters
  Help Functions
  Visiting Files
  Saving Buffers
  Reading from Files
  Writing to Files
  File Locks
  Information about Files
  Contents of Directories
  Changing Files
  File Names
  Visiting Functions
  Subroutines of Visiting
  Testing Accessibility
  Kinds of Files
  File Attributes
  File Name Components
  Directory Names
  Relative File Names
  File Name Expansion
  Unique File Names
  File Name Completion
  Backup Files
  Auto-Saving
  Reverting
  Making Backups
  Rename or Copy
  Numbered Backups
  Backup Names
  Buffer Basics
  Buffer Names
  Buffer File Name
  Buffer Modification
  Modification Time
  Read Only Buffers
  The Buffer List
  Creating Buffers
  Killing Buffers
  Current Buffer
  Basic Windows
  Splitting Windows
  Deleting Windows
  Selecting Windows
  Cyclic Window Ordering
  Buffers and Windows
  Displaying Buffers
  Window Point
  Window Start
  Vertical Scrolling
  Horizontal Scrolling
  Size of Window
  Resizing Windows
  Window Configurations
  Creating Frames
  Multiple Displays
  Frame Parameters
  Frame Titles
  Deleting Frames
  Finding All Frames
  Frames and Windows
  Minibuffers and Frames
  Input Focus
  Visibility of Frames
  Raising and Lowering
  Frame Configurations
  Mouse Tracking
  Mouse Position
  Pop-Up Menus
  Dialog Boxes
  Pointer Shapes
  Window System Selections
  Color Names
  Resources
  Display Feature Testing
  Point
  Motion
  Excursions
  Narrowing
  Character Motion
  Word Motion
  Buffer End Motion
  Text Lines
  Screen Lines
  List Motion
  Skipping Characters
  Overview of Markers
  Predicates on Markers
  Creating Markers
  Information from Markers
  Moving Markers
  The Mark
  The Region
  Near Point
  Buffer Contents
  Insertion
  Commands for Insertion
  Deletion
  User-Level Deletion
  The Kill Ring
  Undo
  Auto Filling
  Filling
  Margins
  Sorting
  Indentation
  Columns
  Case Changes
  Text Properties
  Substitution
  Transposition
  Registers
  Change Hooks
  Kill Ring Concepts
  Kill Functions
  Yank Commands
  Low-Level Kill Ring
  Internals of Kill Ring
  Primitive Indent
  Mode-Specific Indent
  Region Indent
  Relative Indent
  Indent Tabs
  Motion by Indent
  Examining Properties
  Changing Properties
  Property Search
  Special Properties
  Format Properties
  Sticky Properties
  Saving Properties
  Lazy Properties
  Clickable Text
  Fields
  Not Intervals
  Text Representations
  Converting Representations
  Selecting a Representation
  Character Codes
  Character Sets
  Chars and Bytes
  Splitting Characters
  Scanning Charsets
  Translation of Characters
  Coding Systems
  Input Methods
  Locales
  String Search
  Regular Expressions
  Regexp Search
  Match Data
  Saving Match Data
  Standard Regexps
  Searching and Case
  Syntax of Regexps
  Regexp Example
  Syntax Descriptors
  Syntax Table Functions
  Parsing Expressions
  Standard Syntax Tables
  Syntax Table Internals
  Syntax Class Table
  Syntax Flags
  Abbrev Mode
  Abbrev Tables
  Defining Abbrevs
  Abbrev Files
  Abbrev Expansion
  Standard Abbrev Tables
  Subprocess Creation
  Synchronous Processes
  Asynchronous Processes
  Deleting Processes
  Process Information
  Input to Processes
  Signals to Processes
  Output from Processes
  Sentinels
  Network
  Process Buffers
  Filter Functions
  Accepting Output
  Starting Up
  Getting Out
  System Environment
  Terminal Input
  Terminal Output
  Flow Control
  Batch Mode
  Startup Summary
  Init File
  Terminal-Specific
  Command-Line Arguments
  Killing Emacs
  Suspending Emacs
  Refresh Screen
  Truncation
  The Echo Area
  Selective Display
  Overlay Arrow
  Temporary Displays
  Waiting
  Blinking
  Usual Display
  Beeping
  Window Systems
  Building Emacs
  Pure Storage
  Garbage Collection
  Object Internals
  Writing Emacs Primitives
  Buffer Internals
  Window Internals
  Process Internals

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'
     *Note atom: List-related Predicates.

`arrayp'
     *Note arrayp: Array Functions.

`bool-vector-p'
     *Note bool-vector-p: Bool-Vectors.

`bufferp'
     *Note bufferp: Buffer Basics.

`byte-code-function-p'
     *Note byte-code-function-p: Byte-Code Type.

`case-table-p'
     *Note case-table-p: Case Tables.

`char-or-string-p'
     *Note char-or-string-p: Predicates for Strings.

`char-table-p'
     *Note char-table-p: Char-Tables.

`commandp'
     *Note commandp: Interactive Call.

`consp'
     *Note consp: List-related Predicates.

`display-table-p'
     *Note display-table-p: Display Tables.

`floatp'
     *Note floatp: Predicates on Numbers.

`frame-configuration-p'
     *Note frame-configuration-p: Frame Configurations.

`frame-live-p'
     *Note frame-live-p: Deleting Frames.

`framep'
     *Note framep: Frames.

`functionp'
     *Note functionp: Functions.

`integer-or-marker-p'
     *Note integer-or-marker-p: Predicates on Markers.

`integerp'
     *Note integerp: Predicates on Numbers.

`keymapp'
     *Note keymapp: Creating Keymaps.

`keywordp'
     *Note Constant Variables::.

`listp'
     *Note listp: List-related Predicates.

`markerp'
     *Note markerp: Predicates on Markers.

`wholenump'
     *Note wholenump: Predicates on Numbers.

`nlistp'
     *Note nlistp: List-related Predicates.

`numberp'
     *Note numberp: Predicates on Numbers.

`number-or-marker-p'
     *Note number-or-marker-p: Predicates on Markers.

`overlayp'
     *Note overlayp: Overlays.

`processp'
     *Note processp: Processes.

`sequencep'
     *Note sequencep: Sequence Functions.

`stringp'
     *Note stringp: Predicates for Strings.

`subrp'
     *Note subrp: Function Cells.

`symbolp'
     *Note symbolp: Symbols.

`syntax-table-p'
     *Note syntax-table-p: Syntax Tables.

`user-variable-p'
     *Note user-variable-p: Defining Variables.

`vectorp'
     *Note vectorp: Vectors.

`window-configuration-p'
     *Note window-configuration-p: Window Configurations.

`window-live-p'
     *Note window-live-p: Deleting Windows.

`windowp'
     *Note windowp: Basic Windows.

   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 (*note 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 `symbol', `integer',
     `float', `string', `cons', `vector', `char-table', `bool-vector',
     `hash-table', `subr', `compiled-function', `marker', `overlay',
     `window', `buffer', `frame', `process', or `window-configuration'.

          (type-of 1)
               => integer
          (type-of 'nil)
               => symbol
          (type-of '())    ; `()' is `nil'.
               => symbol
          (type-of '(x))
               => cons

back to top
elisp : Type Predicates

table of contents

  Introduction
  Coding Conventions
  Lisp Data Types
  Numbers
  Strings and Characters
  Lists
  Sequences Arrays Vectors
  Hash Tables
  Symbols
  Evaluation
  Control Structures
  Variables
  Functions
  Macros
  Customization
  Loading
  Byte Compilation
  Advising Functions
  Debugging
  Read and Print
  Minibuffers
  Command Loop
  Keymaps
  Modes
  Documentation
  Files
  Backups and Auto-Saving
  Buffers
  Windows
  Frames
  Positions
  Markers
  Text
  Non-ASCII Characters
  Searching and Matching
  Syntax Tables
  Abbrevs
  Processes
  Display
  Calendar
  System Interface
  Antinews
  GNU Free Documentation License
  GPL
  Tips
  GNU Emacs Internals
  Standard Errors
  Standard Buffer-Local Variables
  Standard Keymaps
  Standard Hooks
  Index
  New Symbols
  Caveats
  Lisp History
  Conventions
  Acknowledgements
  Some Terms
  nil and t
  Evaluation Notation
  Printing Notation
  Error Messages
  Buffer Text Notation
  Format of Descriptions
  Coding Conventions
  Compilation Tips
  Documentation Tips
  Comment Tips
  Library Headers
  A Sample Function Description
  A Sample Variable Description
  Printed Representation
  Comments
  Programming Types
  Editing Types
  Type Predicates
  Equality Predicates
  Integer Type
  Floating Point Type
  Character Type
  Sequence Type
  Cons Cell Type
  Array Type
  String Type
  Vector Type
  Symbol Type
  Function Type
  Macro Type
  Primitive Function Type
  Byte-Code Type
  Autoload Type
  Dotted Pair Notation
  Association List Type
  Buffer Type
  Window Type
  Window Configuration Type
  Marker Type
  Process Type
  Stream Type
  Keymap Type
  Overlay Type
  Integer Basics
  Float Basics
  Predicates on Numbers
  Comparison of Numbers
  Arithmetic Operations
  Bitwise Operations
  Numeric Conversions
  Math Functions
  Random Numbers
  String Basics
  Predicates for Strings
  Creating Strings
  Text Comparison
  String Conversion
  Formatting Strings
  Case Conversion
  Cons Cells
  Lists as Boxes
  List-related Predicates
  List Elements
  Building Lists
  Modifying Lists
  Sets And Lists
  Association Lists
  Setcar
  Setcdr
  Rearrangement
  Sequence Functions
  Arrays
  Array Functions
  Vectors
  Symbol Components
  Definitions
  Creating Symbols
  Property Lists
  Intro Eval
  Eval
  Forms
  Quoting
  Self-Evaluating Forms
  Symbol Forms
  Classifying Lists
  Function Forms
  Macro Forms
  Special Forms
  Autoloading
  Sequencing
  Conditionals
  Combining Conditions
  Iteration
  Nonlocal Exits
  Catch and Throw
  Examples of Catch
  Errors
  Cleanups
  Signaling Errors
  Processing of Errors
  Handling Errors
  Error Symbols
  Global Variables
  Constant Variables
  Local Variables
  Void Variables
  Defining Variables
  Accessing Variables
  Setting Variables
  Variable Scoping
  Buffer-Local Variables
  Scope
  Extent
  Impl of Scope
  Using Scoping
  Intro to Buffer-Local
  Creating Buffer-Local
  Default Value
  What Is a Function
  Lambda Expressions
  Function Names
  Defining Functions
  Calling Functions
  Mapping Functions
  Anonymous Functions
  Function Cells
  Related Topics
  Lambda Components
  Simple Lambda
  Argument List
  Function Documentation
  Simple Macro
  Expansion
  Compiling Macros
  Defining Macros
  Backquote
  Problems with Macros
  How Programs Do Loading
  Autoload
  Named Features
  Repeated Loading
  Compilation Functions
  Disassembly
  Simple Advice
  Defining Advice
  Computed Advice
  Activation of Advice
  Enabling Advice
  Preactivation
  Argument Access in Advice
  Subr Arguments
  Combined Definition
  Debugger
  Syntax Errors
  Compilation Errors
  Edebug
  Error Debugging
  Function Debugging
  Explicit Debug
  Using Debugger
  Debugger Commands
  Invoking the Debugger
  Internals of Debugger
  Excess Open
  Excess Close
  Streams Intro
  Input Streams
  Input Functions
  Output Streams
  Output Functions
  Intro to Minibuffers
  Text from Minibuffer
  Object from Minibuffer
  Completion
  Yes-or-No Queries
  Minibuffer Misc
  Basic Completion
  Minibuffer Completion
  Completion Commands
  High-Level Completion
  Reading File Names
  Programmed Completion
  Command Overview
  Defining Commands
  Interactive Call
  Command Loop Info
  Input Events
  Reading Input
  Waiting
  Quitting
  Prefix Command Arguments
  Recursive Editing
  Disabling Commands
  Command History
  Keyboard Macros
  Using Interactive
  Interactive Codes
  Interactive Examples
  Keymap Terminology
  Format of Keymaps
  Creating Keymaps
  Inheritance and Keymaps
  Prefix Keys
  Menu Keymaps
  Active Keymaps
  Key Lookup
  Functions for Key Lookup
  Changing Key Bindings
  Key Binding Commands
  Scanning Keymaps
  Major Modes
  Minor Modes
  Mode Line Format
  Hooks
  Major Mode Conventions
  Example Major Modes
  Auto Major Mode
  Mode Help
  Minor Mode Conventions
  Keymaps and Minor Modes
  Mode Line Data
  Mode Line Variables
  %-Constructs
  Documentation Basics
  Accessing Documentation
  Keys in Documentation
  Describing Characters
  Help Functions
  Visiting Files
  Saving Buffers
  Reading from Files
  Writing to Files
  File Locks
  Information about Files
  Contents of Directories
  Changing Files
  File Names
  Visiting Functions
  Subroutines of Visiting
  Testing Accessibility
  Kinds of Files
  File Attributes
  File Name Components
  Directory Names
  Relative File Names
  File Name Expansion
  Unique File Names
  File Name Completion
  Backup Files
  Auto-Saving
  Reverting
  Making Backups
  Rename or Copy
  Numbered Backups
  Backup Names
  Buffer Basics
  Buffer Names
  Buffer File Name
  Buffer Modification
  Modification Time
  Read Only Buffers
  The Buffer List
  Creating Buffers
  Killing Buffers
  Current Buffer
  Basic Windows
  Splitting Windows
  Deleting Windows
  Selecting Windows
  Cyclic Window Ordering
  Buffers and Windows
  Displaying Buffers
  Window Point
  Window Start
  Vertical Scrolling
  Horizontal Scrolling
  Size of Window
  Resizing Windows
  Window Configurations
  Creating Frames
  Multiple Displays
  Frame Parameters
  Frame Titles
  Deleting Frames
  Finding All Frames
  Frames and Windows
  Minibuffers and Frames
  Input Focus
  Visibility of Frames
  Raising and Lowering
  Frame Configurations
  Mouse Tracking
  Mouse Position
  Pop-Up Menus
  Dialog Boxes
  Pointer Shapes
  Window System Selections
  Color Names
  Resources
  Display Feature Testing
  Point
  Motion
  Excursions
  Narrowing
  Character Motion
  Word Motion
  Buffer End Motion
  Text Lines
  Screen Lines
  List Motion
  Skipping Characters
  Overview of Markers
  Predicates on Markers
  Creating Markers
  Information from Markers
  Moving Markers
  The Mark
  The Region
  Near Point
  Buffer Contents
  Insertion
  Commands for Insertion
  Deletion
  User-Level Deletion
  The Kill Ring
  Undo
  Auto Filling
  Filling
  Margins
  Sorting
  Indentation
  Columns
  Case Changes
  Text Properties
  Substitution
  Transposition
  Registers
  Change Hooks
  Kill Ring Concepts
  Kill Functions
  Yank Commands
  Low-Level Kill Ring
  Internals of Kill Ring
  Primitive Indent
  Mode-Specific Indent
  Region Indent
  Relative Indent
  Indent Tabs
  Motion by Indent
  Examining Properties
  Changing Properties
  Property Search
  Special Properties
  Format Properties
  Sticky Properties
  Saving Properties
  Lazy Properties
  Clickable Text
  Fields
  Not Intervals
  Text Representations
  Converting Representations
  Selecting a Representation
  Character Codes
  Character Sets
  Chars and Bytes
  Splitting Characters
  Scanning Charsets
  Translation of Characters
  Coding Systems
  Input Methods
  Locales
  String Search
  Regular Expressions
  Regexp Search
  Match Data
  Saving Match Data
  Standard Regexps
  Searching and Case
  Syntax of Regexps
  Regexp Example
  Syntax Descriptors
  Syntax Table Functions
  Parsing Expressions
  Standard Syntax Tables
  Syntax Table Internals
  Syntax Class Table
  Syntax Flags
  Abbrev Mode
  Abbrev Tables
  Defining Abbrevs
  Abbrev Files
  Abbrev Expansion
  Standard Abbrev Tables
  Subprocess Creation
  Synchronous Processes
  Asynchronous Processes
  Deleting Processes
  Process Information
  Input to Processes
  Signals to Processes
  Output from Processes
  Sentinels
  Network
  Process Buffers
  Filter Functions
  Accepting Output
  Starting Up
  Getting Out
  System Environment
  Terminal Input
  Terminal Output
  Flow Control
  Batch Mode
  Startup Summary
  Init File
  Terminal-Specific
  Command-Line Arguments
  Killing Emacs
  Suspending Emacs
  Refresh Screen
  Truncation
  The Echo Area
  Selective Display
  Overlay Arrow
  Temporary Displays
  Waiting
  Blinking
  Usual Display
  Beeping
  Window Systems
  Building Emacs
  Pure Storage
  Garbage Collection
  Object Internals
  Writing Emacs Primitives
  Buffer Internals
  Window Internals
  Process Internals