8. Lisp Data Types

A Lisp object is a piece of data used and manipulated by Lisp programs. For our purposes, a type or data type is a set of possible objects.

Every object belongs to at least one type. Objects of the same type have similar structures and may usually be used in the same contexts. Types can overlap, and objects can belong to two or more types. Consequently, we can ask whether an object belongs to a particular type, but not for “the” type of an object.

A few fundamental object types are built into XEmacs. These, from which all other types are constructed, are called primitive types. Each object belongs to one and only one primitive type. These types include integer, character (starting with XEmacs 20.0), float, cons, symbol, string, vector, bit-vector, subr, compiled-function, hash-table, range-table, char-table, weak-list, and several special types, such as buffer, that are related to editing. (See section Editing Types.)

Each primitive type has a corresponding Lisp function that checks whether an object is a member of that type.

Note that Lisp is unlike many other languages in that Lisp objects are self-typing: the primitive type of the object is implicit in the object itself. For example, if an object is a vector, nothing can treat it as a number; Lisp knows it is a vector, not a number.

In most languages, the programmer must declare the data type of each variable, and the type is known by the compiler but not represented in the data. Such type declarations do not exist in XEmacs Lisp. A Lisp variable can have any type of value, and it remembers whatever value you store in it, type and all.

This chapter describes the purpose, printed representation, and read syntax of each of the standard types in Emacs Lisp. Details on how to use these types can be found in later chapters.

8.1 Printed Representation and Read Syntax

The printed representation of an object is the format of the output generated by the Lisp printer (the function prin1) for that object. The read syntax of an object is the format of the input accepted by the Lisp reader (the function read) for that object. Most objects have more than one possible read syntax. Some types of object have no read syntax; except for these cases, the printed representation of an object is also a read syntax for it.

In other languages, an expression is text; it has no other form. In Lisp, an expression is primarily a Lisp object and only secondarily the text that is the object’s read syntax. Often there is no need to emphasize this distinction, but you must keep it in the back of your mind, or you will occasionally be very confused.

Every type has a printed representation. Some types have no read syntax, since it may not make sense to enter objects of these types directly in a Lisp program. For example, the buffer type does not have a read syntax. Objects of these types are printed in hash notation: the characters ‘#<’ followed by a descriptive string (typically the type name followed by the name of the object), and closed with a matching ‘>’. Hash notation cannot be read at all, so the Lisp reader signals the error invalid-read-syntax whenever it encounters ‘#<’.

(current-buffer)
     ⇒ #<buffer "objects.texi">

When you evaluate an expression interactively, the Lisp interpreter first reads the textual representation of it, producing a Lisp object, and then evaluates that object (see section Evaluation). However, evaluation and reading are separate activities. Reading returns the Lisp object represented by the text that is read; the object may or may not be evaluated later. See section Input Functions, for a description of read, the basic function for reading objects.

8.2 Comments

A comment is text that is written in a program only for the sake of humans that read the program, and that has no effect on the meaning of the program. In Lisp, a semicolon (‘;’) starts a comment if it is not within a string or character constant. The comment continues to the end of line. The Lisp reader discards comments; they do not become part of the Lisp objects which represent the program within the Lisp system.

The ‘#@count’ construct, which skips the next count characters, is useful for program-generated comments containing binary data. The XEmacs Lisp byte compiler uses this in its output files (see section Byte Compilation). It isn’t meant for source files, however.

See section Tips on Writing Comments, for conventions for formatting comments.

8.3 Primitive Types

For reference, here is a list of all the primitive types that may exist in XEmacs. Note that some of these types may not exist in some XEmacs executables; that depends on the options that XEmacs was configured with.

• bit-vector
• buffer
• char-table
• character
• charset
• coding-system
• cons
• color-instance
• compiled-function
• console
• database
• device
• event
• extent
• face
• float
• font-instance
• frame
• glyph
• hash-table
• image-instance
• integer
• keymap
• marker
• process
• range-table
• specifier
• string
• subr
• subwindow
• symbol
• toolbar-button
• tooltalk-message
• tooltalk-pattern
• vector
• weak-list
• window
• window-configuration
• x-resource

In addition, the following special types are created internally but will never be seen by Lisp code. You may encounter them, however, if you are debugging XEmacs. The printed representation of these objects begins ‘#<INTERNAL EMACS BUG’, which indicates to the Lisp programmer that he has found an internal bug in XEmacs if he ever encounters any of these objects.

• char-table-entry
• command-builder
• extent-auxiliary
• extent-info
• lcrecord-list
• lstream
• opaque
• opaque-list
• popup-data
• symbol-value-buffer-local
• symbol-value-forward
• symbol-value-lisp-magic
• symbol-value-varalias
• toolbar-data

8.4 Programming Types

There are two general categories of types in XEmacs Lisp: those having to do with Lisp programming, and those having to do with editing. The former exist in many Lisp implementations, in one form or another. The latter are unique to XEmacs Lisp.

8.4.1 Integer Type

In XEmacs Lisp, integers can be fixnums (that is, fixed-precision integers) or bignums (arbitrary-precision integers), if compile-time configuration supports this. The read syntax for the two types is the same, the type chosen depending on the numeric values involved.

The range of values for fixnums in XEmacs Lisp is given by the constants most-positive-fixnum and most-negative-fixnum. On 32-bit machines, these constants reflect 31 value bits, ranging from -1073741824 to 1073741823.

In the absence of See section The Bignum Extension, XEmacs Lisp arithmetic functions do not check for overflow; so the code snippet (= most-negative-fixnum (1+ most-positive-fixnum)) will give t. However, you will get an error if you attempt to read an out-of-range number using the Lisp reader.

The main read syntax for integers is a sequence of base ten digits with an optional sign at the beginning. (The printed representation produced by the Lisp interpreter never has a leading ‘+’.)

-1               ; The integer -1.
1                ; The integer 1.
+1               ; Also the integer 1.
268435457        ; Causes an error on a 28-bit implementation.

See section Numbers, for more information.

8.4.2 Floating Point Type

XEmacs supports floating point numbers. The precise range of floating point numbers is machine-specific.

The printed representation for floating point numbers requires either a decimal point (with at least one digit following), an exponent, or both. For example, ‘1500.0’, ‘15e2’, ‘15.0e2’, ‘1.5e3’, and ‘.15e4’ are five ways of writing a floating point number whose value is 1500. They are all equivalent.

See section Numbers, for more information.

8.4.3 Character Type

In XEmacs version 19, and in all versions of FSF GNU Emacs, a character in XEmacs Lisp is nothing more than an integer. This is yet another holdover from XEmacs Lisp’s derivation from vintage-1980 Lisps; modern versions of Lisp consider this equivalence a bad idea, and have separate character types. In XEmacs version 20, the modern convention is followed, and characters are their own primitive types. (This change was necessary in order for MULE, i.e. Asian-language, support to be correctly implemented.)

Every character has an equivalent integer, called the character code. For example, the character A is represented as the integer 65, following the standard ASCII representation of characters. If XEmacs was not compiled with MULE support, the range of this integer will always be 0 to 255—eight bits, or one byte. (Integers outside this range are accepted but silently truncated; however, you should most decidedly not rely on this, because it will not work under XEmacs with MULE support.) When MULE support is present, the range of character codes is much larger. (Currently, 19 bits are used.)

FSF GNU Emacs uses kludgy character codes above 255 to represent keyboard input of ASCII characters in combination with certain modifiers. XEmacs does not use this (a more general mechanism is used that does not distinguish between ASCII keys and other keys), so you will never find character codes above 255 in a non-MULE XEmacs.

Individual characters are not often used in programs. It is far more common to work with strings, which are sequences composed of characters. See section String Type.

The read syntax for characters begins with a question mark, followed by the character (if it’s printable) or some symbolic representation of it. In XEmacs 20, where characters are their own type, this is also the print representation. In XEmacs 19, however, where characters are really integers, the printed representation of a character is a decimal number. This is also a possible read syntax for a character, but writing characters that way in Lisp programs is a very bad idea. You should always use the special read syntax formats that XEmacs Lisp provides for characters.

The usual read syntax for alphanumeric characters is a question mark followed by the character; thus, ‘?A’ for the character A, ‘?B’ for the character B, and ‘?a’ for the character a.

For example:

;; Under XEmacs 20:
?Q ⇒ ?Q    ?q ⇒ ?q
(char-int ?Q) ⇒ 81
;; Under XEmacs 19:
?Q ⇒ 81     ?q ⇒ 113

You can use the same syntax for punctuation characters, but it is often a good idea to add a ‘\’ so that the Emacs commands for editing Lisp code don’t get confused. For example, ‘?\ ’ is the way to write the space character. If the character is ‘\’, you must use a second ‘\’ to quote it: ‘?\\’. XEmacs 20 always prints punctuation characters with a ‘\’ in front of them, to avoid confusion.

You can express the characters Control-g, backspace, tab, newline, vertical tab, formfeed, return, and escape as ‘?\a’, ‘?\b’, ‘?\t’, ‘?\n’, ‘?\v’, ‘?\f’, ‘?\r’, ‘?\e’, respectively. Their character codes are 7, 8, 9, 10, 11, 12, 13, and 27 in decimal. Thus,

;; Under XEmacs 20:
?\a ⇒ ?\^G              ; C-g
(char-int ?\a) ⇒ 7
?\b ⇒ ?\^H              ; backspace, <BS>, C-h
(char-int ?\b) ⇒ 8
?\t ⇒ ?\t               ; tab, <TAB>, C-i
(char-int ?\t) ⇒ 9
?\n ⇒ ?\n               ; newline, <LFD>, C-j
?\v ⇒ ?\^K              ; vertical tab, C-k
?\f ⇒ ?\^L              ; formfeed character, C-l
?\r ⇒ ?\r               ; carriage return, <RET>, C-m
?\e ⇒ ?\^[              ; escape character, <ESC>, C-[
?\\ ⇒ ?\\               ; backslash character, \
;; Under XEmacs 19:
?\a ⇒ 7                 ; C-g
?\b ⇒ 8                 ; backspace, <BS>, C-h
?\t ⇒ 9                 ; tab, <TAB>, C-i
?\n ⇒ 10                ; newline, <LFD>, C-j
?\v ⇒ 11                ; vertical tab, C-k
?\f ⇒ 12                ; formfeed character, C-l
?\r ⇒ 13                ; carriage return, <RET>, C-m
?\e ⇒ 27                ; escape character, <ESC>, C-[
?\\ ⇒ 92                ; backslash character, \

These sequences which start with backslash are also known as escape sequences, because backslash plays the role of an escape character; this usage has nothing to do with the character <ESC>.

Control characters may be represented using yet another read syntax. This consists of a question mark followed by a backslash, caret, and the corresponding non-control character, in either upper or lower case. For example, both ‘?\^I’ and ‘?\^i’ are valid read syntax for the character C-i, the character whose value is 9.

Instead of the ‘^’, you can use ‘C-’; thus, ‘?\C-i’ is equivalent to ‘?\^I’ and to ‘?\^i’:

;; Under XEmacs 20:
?\^I ⇒ ?\t   ?\C-I ⇒ ?\t
(char-int ?\^I) ⇒ 9
;; Under XEmacs 19:
?\^I ⇒ 9     ?\C-I ⇒ 9

There is also a character read syntax beginning with ‘\M-’. This sets the high bit of the character code (same as adding 128 to the character code). For example, ‘?\M-A’ stands for the character with character code 193, or 128 plus 65. You should not use this syntax in your programs. It is a holdover of yet another confoundance disease from earlier Emacsen. (This was used to represent keyboard input with the <META> key set, thus the ‘M’; however, it conflicts with the legitimate ISO-8859-1 interpretation of the character code. For example, character code 193 is a lowercase ‘a’ with an acute accent, in ISO-8859-1.)

From version 21.5.25 onwards, XEmacs provides a syntax for specifying characters by their Unicode code points. ‘?\uABCD’ will give you an XEmacs character that maps to the code point ‘U+ABCD’ in Unicode-based representations (UTF-8 text files, Unicode-oriented fonts, etc.) Just as in the C# language, there is a slightly different syntax for specifying characters with code points above ‘#xFFFF’; ‘\U00ABCDEF’ will give you an XEmacs character that maps to the code point ‘U+ABCDEF’ in Unicode-based representations, if such an XEmacs character exists.

Unlike in C#, while this syntax is available for character literals, and (see later) in strings, it is not available elsewhere in your Lisp source code.

Finally, there are two read syntaxes involving character codes. It is not possible to represent multibyte or wide characters in this way; the permissible range of codes is from 0 to 255 (i.e., ‘0377’ octal or ‘0xFF’ hexadecimal). If you wish to convert code points to other characters, you must use the ‘make-char’ or ‘unicode-to-char’ primitives in Mule. (Non-Mule XEmacsen cannot represent codes out of that range at all, although you can set the font to a registry other than ISO 8859/1 to get the appearance of a greater range of characters.) Although these syntaxes can represent any ASCII or Latin-1 character, they are preferred only when the precise integral value is more important than the ASCII representation.

The first consists of a question mark followed by a backslash and the character code in octal (up to three octal digits); thus, ‘?\101’ for the character A, ‘?\001’ for the character C-a, and ?\002 for the character C-b. The reader will finalize the character and start reading the next token when a non-octal-digit is encountered or three octal digits are read. When a given character code is above #o377, the Lisp reader signals an invalid-read-syntax error. Such errors are typically provoked by code written for older versions of GNU Emacs, where the absence of the #o octal syntax for integers made the character syntax convenient for non-character values. Those older versions of GNU Emacs are long obsolete, so changing the code to use the #o integer escape is the best solution. see section Numbers.

The second consists of a question mark followed by a backslash, the character ‘x’, and the character code in hexadecimal (up to two hexadecimal digits); thus, ‘?\x41’ for the character A, ‘?\x1’ for the character C-a, and ?\x2 for the character C-b. If more than two hexadecimal codes are given, the reader signals an invalid-read-syntax error.

;; Under XEmacs 20:
?\012 ⇒ ?\n        ?\n ⇒ ?\n        ?\C-j ⇒ ?\n
?\101 ⇒ ?A         ?A ⇒ ?A          ?\x0A ⇒ ?\n
?\x41 ⇒ ?A     '(?\xAZ) ⇒ '(?\n Z)  '(?\0123) ⇒ (?\n 3)

;; Under XEmacs 19:
?\012 ⇒ 10         ?\n ⇒ 10         ?\C-j ⇒ 10
?\101 ⇒ 65         ?A ⇒ 65
;; ?\x41 is a syntax error.

A backslash is allowed, and harmless, preceding any character without a special escape meaning; thus, ‘?\+’ is equivalent to ‘?+’. There is no reason to add a backslash before most characters. However, you should add a backslash before any of the characters ‘()\|;'`"#.,’ to avoid confusing the Emacs commands for editing Lisp code. Also add a backslash before whitespace characters such as space, tab, newline and formfeed. However, it is cleaner to use one of the easily readable escape sequences, such as ‘\t’, instead of an actual whitespace character such as a tab.

8.4.4 Symbol Type

A symbol in XEmacs Lisp is an object with a name. The symbol name serves as the printed representation of the symbol. In ordinary use, the name is unique—no two symbols have the same name.

A symbol can serve as a variable, as a function name, or to hold a property list. Or it may serve only to be distinct from all other Lisp objects, so that its presence in a data structure may be recognized reliably. In a given context, usually only one of these uses is intended. But you can use one symbol in all of these ways, independently.

A symbol name can contain any characters whatever. Most symbol names are written with letters, digits, and the punctuation characters ‘-+=*/’. Such names require no special punctuation; the characters of the name suffice as long as the name does not look like a number. (If it does, write a ‘\’ at the beginning of the name to force interpretation as a symbol.) The characters ‘_~!@$%^&:<>{}’ are less often used but also require no special punctuation. Any other characters may be included in a symbol’s name by escaping them with a backslash. In contrast to its use in strings, however, a backslash in the name of a symbol simply quotes the single character that follows the backslash. For example, in a string, ‘\t’ represents a tab character; in the name of a symbol, however, ‘\t’ merely quotes the letter t. To have a symbol with a tab character in its name, you must actually use a tab (preceded with a backslash). But it’s rare to do such a thing.

Common Lisp note: In Common Lisp, lower case letters are always “folded” to upper case, unless they are explicitly escaped. In Emacs Lisp, upper case and lower case letters are distinct.

Here are several examples of symbol names. Note that the ‘+’ in the fifth example is escaped to prevent it from being read as a number. This is not necessary in the sixth example because the rest of the name makes it invalid as a number.

foo                 ; A symbol named ‘foo’.
FOO                 ; A symbol named ‘FOO’, different from ‘foo’.
char-to-string      ; A symbol named ‘char-to-string’.

1+                  ; A symbol named ‘1+’
                    ;   (not ‘+1’, which is an integer).

\+1                 ; A symbol named ‘+1’
                    ;   (not a very readable name).

\(*\ 1\ 2\)         ; A symbol named ‘(* 1 2)’ (a worse name).
+-*/_~!@$%^&=:<>{}  ; A symbol named ‘+-*/_~!@$%^&=:<>{}’.
                    ;   These characters need not be escaped.

8.4.5 Sequence Types

A sequence is a Lisp object that represents an ordered set of elements. There are two kinds of sequence in XEmacs Lisp, lists and arrays. Thus, an object of type list or of type array is also considered a sequence.

Arrays are further subdivided into strings, vectors, and bit vectors. Vectors can hold elements of any type, but string elements must be characters, and bit vector elements must be either 0 or 1. However, the characters in a string can have extents (see section Extents) and text properties (see section Text Properties) like characters in a buffer; vectors do not support extents or text properties even when their elements happen to be characters.

Lists, strings, vectors, and bit vectors are different, but they have important similarities. For example, all have a length l, and all have elements which can be indexed from zero to l minus one. Also, several functions, called sequence functions, accept any kind of sequence. For example, the function elt can be used to extract an element of a sequence, given its index. See section Sequences, Arrays, and Vectors.

It is impossible to read the same sequence twice, since sequences are always created anew upon reading. If you read the read syntax for a sequence twice, you get two sequences with equal contents. There is one exception: the empty list () always stands for the same object, nil.

8.4.6 Cons Cell and List Types

A cons cell is an object comprising two pointers named the CAR and the CDR. Each of them can point to any Lisp object.

A list is a series of cons cells, linked together so that the CDR of each cons cell points either to another cons cell or to the empty list. See section Lists, for functions that work on lists. Because most cons cells are used as part of lists, the phrase list structure has come to refer to any structure made out of cons cells.

The names CAR and CDR have only historical meaning now. The original Lisp implementation ran on an IBM 704 computer which divided words into two parts, called the “address” part and the “decrement”; CAR was an instruction to extract the contents of the address part of a register, and CDR an instruction to extract the contents of the decrement. By contrast, “cons cells” are named for the function cons that creates them, which in turn is named for its purpose, the construction of cells.

Because cons cells are so central to Lisp, we also have a word for “an object which is not a cons cell”. These objects are called atoms.

The read syntax and printed representation for lists are identical, and consist of a left parenthesis, an arbitrary number of elements, and a right parenthesis.

Upon reading, each object inside the parentheses becomes an element of the list. That is, a cons cell is made for each element. The CAR of the cons cell points to the element, and its CDR points to the next cons cell of the list, which holds the next element in the list. The CDR of the last cons cell is set to point to nil.

A list can be illustrated by a diagram in which the cons cells are shown as pairs of boxes. (The Lisp reader cannot read such an illustration; unlike the textual notation, which can be understood by both humans and computers, the box illustrations can be understood only by humans.) The following represents the three-element list (rose violet buttercup):

    ___ ___      ___ ___      ___ ___
   |___|___|--> |___|___|--> |___|___|--> nil
     |            |            |
     |            |            |
      --> rose     --> violet   --> buttercup

In this diagram, each box represents a slot that can refer to any Lisp object. Each pair of boxes represents a cons cell. Each arrow is a reference to a Lisp object, either an atom or another cons cell.

In this example, the first box, the CAR of the first cons cell, refers to or “contains” rose (a symbol). The second box, the CDR of the first cons cell, refers to the next pair of boxes, the second cons cell. The CAR of the second cons cell refers to violet and the CDR refers to the third cons cell. The CDR of the third (and last) cons cell refers to nil.

Here is another diagram of the same list, (rose violet buttercup), sketched in a different manner:

 ---------------       ----------------       -------------------
| car   | cdr   |     | car    | cdr   |     | car       | cdr   |
| rose  |   o-------->| violet |   o-------->| buttercup |  nil  |
|       |       |     |        |       |     |           |       |
 ---------------       ----------------       -------------------

A list with no elements in it is the empty list; it is identical to the symbol nil. In other words, nil is both a symbol and a list.

Here are examples of lists written in Lisp syntax:

(A 2 "A")            ; A list of three elements.
()                   ; A list of no elements (the empty list).
nil                  ; A list of no elements (the empty list).
("A ()")             ; A list of one element: the string "A ()".
(A ())               ; A list of two elements: A and the empty list.
(A nil)              ; Equivalent to the previous.
((A B C))            ; A list of one element
                     ;   (which is a list of three elements).

Here is the list (A ()), or equivalently (A nil), depicted with boxes and arrows:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> nil
     |            |
     |            |
      --> A        --> nil

8.4.6.1 Dotted Pair Notation

Dotted pair notation is an alternative syntax for cons cells that represents the CAR and CDR explicitly. In this syntax, (a . b) stands for a cons cell whose CAR is the object a, and whose CDR is the object b. Dotted pair notation is therefore more general than list syntax. In the dotted pair notation, the list ‘(1 2 3)’ is written as ‘(1 . (2 . (3 . nil)))’. For nil-terminated lists, the two notations produce the same result, but list notation is usually clearer and more convenient when it is applicable. When printing a list, the dotted pair notation is only used if the CDR of a cell is not a list.

Here’s how box notation can illustrate dotted pairs. This example shows the pair (rose . violet):

    ___ ___
   |___|___|--> violet
     |
     |
      --> rose

Dotted pair notation can be combined with list notation to represent a chain of cons cells with a non-nil final CDR. For example, (rose violet . buttercup) is equivalent to (rose . (violet . buttercup)). The object looks like this:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> buttercup
     |            |
     |            |
      --> rose     --> violet

These diagrams make it evident why (rose . violet . buttercup) is invalid syntax; it would require a cons cell that has three parts rather than two.

The list (rose violet) is equivalent to (rose . (violet)) and looks like this:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> nil
     |            |
     |            |
      --> rose     --> violet

Similarly, the three-element list (rose violet buttercup) is equivalent to (rose . (violet . (buttercup))).

8.4.6.2 Association List Type

An association list or alist is a specially-constructed list whose elements are cons cells. In each element, the CAR is considered a key, and the CDR is considered an associated value. (In some cases, the associated value is stored in the CAR of the CDR.) Association lists are often used as stacks, since it is easy to add or remove associations at the front of the list.

For example,

(setq alist-of-colors
      '((rose . red) (lily . white)  (buttercup . yellow)))

sets the variable alist-of-colors to an alist of three elements. In the first element, rose is the key and red is the value.

See section Association Lists, for a further explanation of alists and for functions that work on alists.

8.4.7 Array Type

An array is composed of an arbitrary number of slots for referring to other Lisp objects, arranged in a contiguous block of memory. Accessing any element of an array takes the same amount of time. In contrast, accessing an element of a list requires time proportional to the position of the element in the list. (Elements at the end of a list take longer to access than elements at the beginning of a list.)

XEmacs defines three types of array, strings, vectors, and bit vectors. A string is an array of characters, a vector is an array of arbitrary objects, and a bit vector is an array of 1’s and 0’s. All are one-dimensional. (Most other programming languages support multidimensional arrays, but they are not essential; you can get the same effect with an array of arrays.) Each type of array has its own read syntax; see String Type, Vector Type, and Bit Vector Type.

An array may have any length up to the largest fixnum; but once created, it has a fixed size. The first element of an array has index zero, the second element has index 1, and so on. This is called zero-origin indexing. For example, an array of four elements has indices 0, 1, 2, and 3.

The array type is contained in the sequence type and contains the string type, the vector type, and the bit vector type.

8.4.8 String Type

A string is an array of characters. Strings are used for many purposes in XEmacs, as can be expected in a text editor; for example, as the names of Lisp symbols, as messages for the user, and to represent text extracted from buffers. Strings in Lisp are constants: evaluation of a string returns the same string.

The read syntax for strings is a double-quote, an arbitrary number of characters, and another double-quote, "like this". The Lisp reader accepts the same formats for reading the characters of a string as it does for reading single characters (without the question mark that begins a character literal). You can enter a nonprinting character such as tab or C-a using the convenient escape sequences, like this: "\t, \C-a". You can include a double-quote in a string by preceding it with a backslash; thus, "\"" is a string containing just a single double-quote character. (See section Character Type, for a description of the read syntax for characters.)

The printed representation of a string consists of a double-quote, the characters it contains, and another double-quote. However, you must escape any backslash or double-quote characters in the string with a backslash, like this: "this \" is an embedded quote".

An alternative syntax allows insertion of raw backslashes into a string, like this: #r"this \ is an embedded backslash". In such a string, each character following a backslash is included literally in the string, and all backslashes are left in the string. This means that #r"\"" is a valid string literal with two characters, a backslash and a double-quote. It also means that a string with this syntax cannot end in a single backslash. As with Python, from where this syntax was taken, you can specify u or U after the #r to specify that interpretation of Unicode escapes should be done—see section Character Type—and if you use #ru for your raw strings, the restriction on the trailing backslash can be worked around like so: #ru"Backslash: \u005C".

The newline character is not special in the read syntax for strings; if you write a new line between the double-quotes, it becomes a character in the string. But an escaped newline—one that is preceded by ‘\’—does not become part of the string; i.e., the Lisp reader ignores an escaped newline while reading a string.

"It is useful to include newlines
in documentation strings,
but the newline is \
ignored if escaped."
     ⇒ "It is useful to include newlines
in documentation strings,
but the newline is ignored if escaped."

A string can hold extents and properties of the text it contains, in addition to the characters themselves. This enables programs that copy text between strings and buffers to preserve the extents and properties with no special effort. See section Extents, See section Text Properties.

Note that FSF GNU Emacs has a special read and print syntax for strings with text properties, but XEmacs does not currently implement this. It was judged better not to include this in XEmacs because it entails that equal return nil when passed a string with text properties and the equivalent string without text properties, which is often counter-intuitive.

See section Strings and Characters, for functions that work on strings.

8.4.9 Vector Type

A vector is a one-dimensional array of elements of any type. It takes a constant amount of time to access any element of a vector. (In a list, the access time of an element is proportional to the distance of the element from the beginning of the list.)

The printed representation of a vector consists of a left square bracket, the elements, and a right square bracket. This is also the read syntax. Like numbers and strings, vectors are considered constants for evaluation.

[1 "two" (three)]      ; A vector of three elements.
     ⇒ [1 "two" (three)]

See section Vectors, for functions that work with vectors.

8.4.10 Bit Vector Type

A bit vector is a one-dimensional array of 1’s and 0’s. It takes a constant amount of time to access any element of a bit vector, as for vectors. Bit vectors have an extremely compact internal representation (one machine bit per element), which makes them ideal for keeping track of unordered sets, large collections of boolean values, etc.

The printed representation of a bit vector consists of ‘#*’ followed by the bits in the vector. This is also the read syntax. Like numbers, strings, and vectors, bit vectors are considered constants for evaluation.

#*00101000      ; A bit vector of eight elements.
     ⇒ #*00101000

See section Bit Vectors, for functions that work with bit vectors.

8.4.11 Function Type

Just as functions in other programming languages are executable, Lisp function objects are pieces of executable code. However, functions in Lisp are primarily Lisp objects, and only secondarily the text which represents them. These Lisp objects are lambda expressions: lists whose first element is the symbol lambda (see section Lambda Expressions).

In most programming languages, it is impossible to have a function without a name. In Lisp, a function has no intrinsic name. A lambda expression is also called an anonymous function (see section Anonymous Functions). A named function in Lisp is actually a symbol with a valid function in its function cell (see section Defining Functions).

Most of the time, functions are called when their names are written in Lisp expressions in Lisp programs. However, you can construct or obtain a function object at run time and then call it with the primitive functions funcall and apply. See section Calling Functions.

8.4.12 Macro Type

A Lisp macro is a user-defined construct that extends the Lisp language. It is represented as an object much like a function, but with different parameter-passing semantics. A Lisp macro has the form of a list whose first element is the symbol macro and whose CDR is a Lisp function object, including the lambda symbol.

Lisp macro objects are usually defined with the built-in defmacro function, but any list that begins with macro is a macro as far as XEmacs is concerned. See section Macros, for an explanation of how to write a macro.

8.4.13 Primitive Function Type

A primitive function is a function callable from Lisp but written in the C programming language. Primitive functions are also called subrs or built-in functions. (The word “subr” is derived from “subroutine”.) Most primitive functions evaluate all their arguments when they are called. A primitive function that does not evaluate all its arguments is called a special operator (see section Special Operators).

It does not matter to the caller of a function whether the function is primitive. However, this does matter if you try to substitute a function written in Lisp for a primitive of the same name. The reason is that the primitive function may be called directly from C code. Calls to the redefined function from Lisp will use the new definition, but calls from C code may still use the built-in definition.

The term function refers to all Emacs functions, whether written in Lisp or C. See section Function Type, for information about the functions written in Lisp.

Primitive functions have no read syntax and print in hash notation with the name of the subroutine.

(symbol-function 'car)          ; Access the function cell
                                ;   of the symbol.
     ⇒ #<subr car>
(subrp (symbol-function 'car))  ; Is this a primitive function?
     ⇒ t                       ; Yes.

8.4.14 Compiled-Function Type

The byte compiler produces compiled-function objects. The evaluator handles this data type specially when it appears as a function to be called. See section Byte Compilation, for information about the byte compiler.

The printed representation for a compiled-function object is normally ‘#<compiled-function...>’. If print-readably is true, however, it is ‘#[...]’.

8.4.15 Autoload Type

An autoload object is a list whose first element is the symbol autoload. It is stored as the function definition of a symbol as a placeholder for the real definition; it says that the real definition is found in a file of Lisp code that should be loaded when necessary. The autoload object contains the name of the file, plus some other information about the real definition.

After the file has been loaded, the symbol should have a new function definition that is not an autoload object. The new definition is then called as if it had been there to begin with. From the user’s point of view, the function call works as expected, using the function definition in the loaded file.

An autoload object is usually created with the function autoload, which stores the object in the function cell of a symbol. See section Autoload, for more details.

8.4.16 Char Table Type

(not yet documented)

8.4.17 Hash Table Type

A hash table is a table providing an arbitrary mapping from one Lisp object to another, using an internal indexing method called hashing. Hash tables are very fast (much more efficient that using an association list, when there are a large number of elements in the table).

Hash tables have a special read syntax beginning with ‘#s(hash-table’ (this is an example of structure read syntax. This notation is also used for printing when print-readably is t.

Otherwise they print in hash notation (The “hash” in “hash notation” has nothing to do with the “hash” in “hash table”), giving the number of elements, total space allocated for elements, and a unique number assigned at the time the hash table was created. (Hash tables automatically resize as necessary so there is no danger of running out of space for elements.)

(make-hash-table :size 50)
     ⇒ #<hash-table :size 0/107 0x3babb0e4>

See section Hash Tables, for information on how to create and work with hash tables.

8.4.18 Range Table Type

A range table is a table that maps from ranges of fixnums to arbitrary Lisp objects. Range tables automatically combine overlapping ranges that map to the same Lisp object, and operations are provided for mapping over all of the ranges in a range table.

Range tables have a special read syntax beginning with ‘#s(range-table’ (this is an example of structure read syntax, which is also used for char tables and faces).

(setq x (make-range-table))
(put-range-table 20 50 'foo x)
(put-range-table 100 200 "bar" x)
x
     ⇒ #s(range-table data ((20 50) foo (100 200) "bar"))

See section Range Tables, for information on how to create and work with range tables.

8.4.19 Weak List Type

(not yet documented)

8.5 Editing Types

The types in the previous section are common to many Lisp dialects. XEmacs Lisp provides several additional data types for purposes connected with editing.

8.5.1 Buffer Type

A buffer is an object that holds text that can be edited (see section Buffers). Most buffers hold the contents of a disk file (see section Files) so they can be edited, but some are used for other purposes. Most buffers are also meant to be seen by the user, and therefore displayed, at some time, in a window (see section Windows). But a buffer need not be displayed in any window.

The contents of a buffer are much like a string, but buffers are not used like strings in XEmacs Lisp, and the available operations are different. For example, insertion of text into a buffer is very efficient, whereas “inserting” text into a string requires concatenating substrings, and the result is an entirely new string object.

Each buffer has a designated position called point (see section Positions). At any time, one buffer is the current buffer. Most editing commands act on the contents of the current buffer in the neighborhood of point. Many of the standard Emacs functions manipulate or test the characters in the current buffer; a whole chapter in this manual is devoted to describing these functions (see section Text).

Several other data structures are associated with each buffer:

• a local syntax table (see section Syntax Tables);
• a local keymap (see section Keymaps);
• a local variable binding list (see section Buffer-Local Variables);
• a list of extents (see section Extents);
• and various other related properties.

The local keymap and variable list contain entries that individually override global bindings or values. These are used to customize the behavior of programs in different buffers, without actually changing the programs.

A buffer may be indirect, which means it shares the text of another buffer. See section Indirect Buffers.

Buffers have no read syntax. They print in hash notation, showing the buffer name.

(current-buffer)
     ⇒ #<buffer "objects.texi">

8.5.2 Marker Type

A marker denotes a position in a specific buffer. Markers therefore have two components: one for the buffer, and one for the position. Changes in the buffer’s text automatically relocate the position value as necessary to ensure that the marker always points between the same two characters in the buffer.

Markers have no read syntax. They print in hash notation, giving the current character position and the name of the buffer.

(point-marker)
     ⇒ #<marker at 50661 in objects.texi>

See section Markers, for information on how to test, create, copy, and move markers.

8.5.3 Extent Type

An extent specifies temporary alteration of the display appearance of a part of a buffer (or string). It contains markers delimiting a range of the buffer, plus a property list (a list whose elements are alternating property names and values). Extents are used to present parts of the buffer temporarily in a different display style. They have no read syntax, and print in hash notation, giving the buffer name and range of positions.

Extents can exist over strings as well as buffers; the primary use of this is to preserve extent and text property information as text is copied from one buffer to another or between different parts of a buffer.

Extents have no read syntax. They print in hash notation, giving the range of text they cover, the name of the buffer or string they are in, the address in core, and a summary of some of the properties attached to the extent.

(extent-at (point))
     ⇒ #<extent [51742, 51748) font-lock text-prop 0x90121e0 in buffer objects.texi>

See section Extents, for how to create and use extents.

Extents are used to implement text properties. See section Text Properties.

8.5.4 Window Type

A window describes the portion of the frame that XEmacs uses to display a buffer. (In standard window-system usage, a window is what XEmacs calls a frame; XEmacs confusingly uses the term “window” to refer to what is called a pane in standard window-system usage.) Every window has one associated buffer, whose contents appear in the window. By contrast, a given buffer may appear in one window, no window, or several windows.

Though many windows may exist simultaneously, at any time one window is designated the selected window. This is the window where the cursor is (usually) displayed when XEmacs is ready for a command. The selected window usually displays the current buffer, but this is not necessarily the case.

Windows are grouped on the screen into frames; each window belongs to one and only one frame. See section Frame Type.

Windows have no read syntax. They print in hash notation, giving the name of the buffer being displayed and a unique number assigned at the time the window was created. (This number can be useful because the buffer displayed in any given window can change frequently.)

(selected-window)
     ⇒ #<window on "objects.texi" 0x266c>

See section Windows, for a description of the functions that work on windows.

8.5.5 Frame Type

A frame is a rectangle on the screen (a window in standard window-system terminology) that contains one or more non-overlapping Emacs windows (panes in standard window-system terminology). A frame initially contains a single main window (plus perhaps a minibuffer window) which you can subdivide vertically or horizontally into smaller windows.

Frames have no read syntax. They print in hash notation, giving the frame’s type, name as used for resourcing, and a unique number assigned at the time the frame was created.

(selected-frame)
     ⇒ #<x-frame "emacs" 0x9db>

See section Frames, for a description of the functions that work on frames.

8.5.6 Device Type

A device represents a single display on which frames exist. Normally, there is only one device object, but there may be more than one if XEmacs is being run on a multi-headed display (e.g. an X server with attached color and mono screens) or if XEmacs is simultaneously driving frames attached to different consoles, e.g. an X display and a TTY connection.

Devices do not have a read syntax. They print in hash notation, giving the device’s type, connection name, and a unique number assigned at the time the device was created.

(selected-device)
     ⇒ #<x-device on ":0.0" 0x5b9>

See section Consoles and Devices, for a description of several functions related to devices.

8.5.7 Console Type

A console represents a single keyboard to which devices (i.e. displays on which frames exist) are connected. Normally, there is only one console object, but there may be more than one if XEmacs is simultaneously driving frames attached to different X servers and/or TTY connections. (XEmacs is capable of driving multiple X and TTY connections at the same time, and provides a robust mechanism for handling the differing display capabilities of such heterogeneous environments. A buffer with embedded glyphs and multiple fonts and colors, for example, will display reasonably if it simultaneously appears on a frame on a color X display, a frame on a mono X display, and a frame on a TTY connection.)

Consoles do not have a read syntax. They print in hash notation, giving the console’s type, connection name, and a unique number assigned at the time the console was created.

(selected-console)
     ⇒ #<x-console on "localhost:0" 0x5b7>

See section Consoles and Devices, for a description of several functions related to consoles.

8.5.8 Window Configuration Type

A window configuration stores information about the positions, sizes, and contents of the windows in a frame, so you can recreate the same arrangement of windows later.

Window configurations do not have a read syntax. They print in hash notation, giving a unique number assigned at the time the window configuration was created.

(current-window-configuration)
     ⇒ #<window-configuration 0x2db4>

See section Window Configurations, for a description of several functions related to window configurations.

8.5.9 Event Type

(not yet documented)

8.5.10 Process Type

The word process usually means a running program. XEmacs itself runs in a process of this sort. However, in XEmacs Lisp, a process is a Lisp object that designates a subprocess created by the XEmacs process. Programs such as shells, GDB, ftp, and compilers, running in subprocesses of XEmacs, extend the capabilities of XEmacs.

An Emacs subprocess takes textual input from Emacs and returns textual output to Emacs for further manipulation. Emacs can also send signals to the subprocess.

Process objects have no read syntax. They print in hash notation, giving the name of the process, its associated process ID, and the current state of the process:

(process-list)
     ⇒ (#<process "shell" pid 2909 state:run>)

See section Processes, for information about functions that create, delete, return information about, send input or signals to, and receive output from processes.

8.5.11 Stream Type

A stream is an object that can be used as a source or sink for characters—either to supply characters for input or to accept them as output. Many different types can be used this way: markers, buffers, strings, and functions. Most often, input streams (character sources) obtain characters from the keyboard, a buffer, or a file, and output streams (character sinks) send characters to a buffer, such as a ‘*Help*’ buffer, or to the echo area.

The object nil, in addition to its other meanings, may be used as a stream. It stands for the value of the variable standard-input or standard-output. Also, the object t as a stream specifies input using the minibuffer (see section Minibuffers) or output in the echo area (see section The Echo Area).

Streams have no special printed representation or read syntax, and print as whatever primitive type they are.

See section Reading and Printing Lisp Objects, for a description of functions related to streams, including parsing and printing functions.

8.5.12 Keymap Type

A keymap maps keys typed by the user to commands. This mapping controls how the user’s command input is executed.

NOTE: In XEmacs, a keymap is a separate primitive type. In FSF GNU Emacs, a keymap is actually a list whose CAR is the symbol keymap.

See section Keymaps, for information about creating keymaps, handling prefix keys, local as well as global keymaps, and changing key bindings.

8.5.13 Syntax Table Type

Under XEmacs 20, a syntax table is a particular type of char table. Under XEmacs 19, a syntax table is a vector of 256 integers. In both cases, each element defines how one character is interpreted when it appears in a buffer. For example, in C mode (see section Major Modes), the ‘+’ character is punctuation, but in Lisp mode it is a valid character in a symbol. These modes specify different interpretations by changing the syntax table entry for ‘+’.

Syntax tables are used only for scanning text in buffers, not for reading Lisp expressions. The table the Lisp interpreter uses to read expressions is built into the XEmacs source code and cannot be changed; thus, to change the list delimiters to be ‘{’ and ‘}’ instead of ‘(’ and ‘)’ would be impossible.

See section Syntax Tables, for details about syntax classes and how to make and modify syntax tables.

8.5.14 Display Table Type

A display table specifies how to display each character code. Each buffer and each window can have its own display table. A display table is actually a vector of length 256, although in XEmacs 20 this may change to be a particular type of char table. See section Display Tables.

8.5.15 Database Type

(not yet documented)

8.5.16 Charset Type

(not yet documented)

8.5.17 Coding System Type

(not yet documented)

8.5.18 ToolTalk Message Type

(not yet documented)

8.5.19 ToolTalk Pattern Type

(not yet documented)

8.6 Window-System Types

XEmacs also has some types that represent objects such as faces (collections of display characters), fonts, and pixmaps that are commonly found in windowing systems.

8.6.1 Face Type

(not yet documented)

8.6.2 Glyph Type

(not yet documented)

8.6.3 Specifier Type

(not yet documented)

8.6.4 Font Instance Type

(not yet documented)

8.6.5 Color Instance Type

(not yet documented)

8.6.6 Image Instance Type

(not yet documented)

8.6.7 Toolbar Button Type

(not yet documented)

8.6.8 Subwindow Type

(not yet documented)

8.6.9 X Resource Type

(not yet documented)

8.7 Type Predicates

The XEmacs 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: integer-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 only handle 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.

annotationp

See section annotationp.

arrayp

See section arrayp.

atom

See section atom.

bit-vector-p

See section bit-vector-p.

bitp

See section bitp.

boolean-specifier-p

See section boolean-specifier-p.

buffer-glyph-p

See section buffer-glyph-p.

buffer-live-p

See section buffer-live-p.

bufferp

See section bufferp.

button-event-p

See section button-event-p.

button-press-event-p

See section button-press-event-p.

button-release-event-p

See section button-release-event-p.

case-table-p

See section case-table-p.

char-int-p

See section char-int-p.

char-or-char-int-p

See section char-or-char-int-p.

char-or-string-p

See section char-or-string-p.

char-table-p

See section char-table-p.

characterp

See section characterp.

color-instance-p

See section color-instance-p.

color-pixmap-image-instance-p

See section color-pixmap-image-instance-p.

color-specifier-p

See section color-specifier-p.

commandp

See section commandp.

compiled-function-p

See section compiled-function-p.

console-live-p

See section console-live-p.

consolep

See section consolep.

consp

See section consp.

database-live-p

See section database-live-p.

databasep

See section databasep.

device-live-p

See section device-live-p.

device-or-frame-p

See section device-or-frame-p.

devicep

See section devicep.

eval-event-p

See section eval-event-p.

event-live-p

See section event-live-p.

eventp

See section eventp.

extent-live-p

See section extent-live-p.

extentp

See section extentp.

face-boolean-specifier-p

See section face-boolean-specifier-p.

facep

See section facep.

floatp

See section floatp.

font-instance-p

See section font-instance-p.

font-specifier-p

See section font-specifier-p.

frame-live-p

See section frame-live-p.

framep

See section framep.

functionp

(not yet documented)

generic-specifier-p

See section generic-specifier-p.

glyphp

See section glyphp.

hash-table-p

See section hash-table-p.

icon-glyph-p

See section icon-glyph-p.

image-instance-p

See section image-instance-p.

image-specifier-p

See section image-specifier-p.

integer-char-or-marker-p

See section integer-char-or-marker-p.

integer-or-char-p

See section integer-or-char-p.

integer-or-marker-p

See section integer-or-marker-p.

integer-specifier-p

See section integer-specifier-p.

integerp

See section integerp.

itimerp

(not yet documented)

key-press-event-p

See section key-press-event-p.

keymapp

See section keymapp.

keywordp

(not yet documented)

listp

See section listp.

markerp

See section markerp.

misc-user-event-p

See section misc-user-event-p.

mono-pixmap-image-instance-p

See section mono-pixmap-image-instance-p.

motion-event-p

See section motion-event-p.

mouse-event-p

See section mouse-event-p.

natnum-specifier-p

See section natnum-specifier-p.

natnump

See section natnump.

nlistp

See section nlistp.

nothing-image-instance-p

See section nothing-image-instance-p.

number-char-or-marker-p

See section number-char-or-marker-p.

number-or-marker-p

See section number-or-marker-p.

numberp

See section numberp.

pointer-glyph-p

See section pointer-glyph-p.

pointer-image-instance-p

See section pointer-image-instance-p.

process-event-p

See section process-event-p.

processp

See section processp.

range-table-p

See section range-table-p.

ringp

(not yet documented)

sequencep

See section sequencep.

specifierp

See section specifierp.

stringp

See section stringp.

subrp

See section subrp.

subwindow-image-instance-p

See section subwindow-image-instance-p.

subwindowp

See section subwindowp.

symbolp

See section symbolp.

syntax-table-p

See section syntax-table-p.

text-image-instance-p

See section text-image-instance-p.

timeout-event-p

See section timeout-event-p.

toolbar-button-p

See section toolbar-button-p.

toolbar-specifier-p

See section toolbar-specifier-p.

user-variable-p

See section user-variable-p.

vectorp

See section vectorp.

weak-list-p

See section weak-list-p.

window-configuration-p

See section window-configuration-p.

window-live-p

See section window-live-p.

windowp

See section windowp.

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 section 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 bit-vector, buffer, char-table, character, charset, coding-system, cons, color-instance, compiled-function, console, database, device, event, extent, face, float, font-instance, frame, glyph, hash-table, image-instance, integer, keymap, marker, process, range-table, specifier, string, subr, subwindow, symbol, toolbar-button, tooltalk-message, tooltalk-pattern, vector, weak-list, window, window-configuration, or x-resource.

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

equalp can also provoke an error if handed a circular structure, as with equal.

This document was generated by Aidan Kehoe on December 27, 2016 using texi2html 1.82.