2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998-1999, 2001-2015 Free Software
5 @c See the file elisp.texi for copying conditions.
7 @chapter Lisp Data Types
13 A Lisp @dfn{object} is a piece of data used and manipulated by Lisp
14 programs. For our purposes, a @dfn{type} or @dfn{data type} is a set of
17 Every object belongs to at least one type. Objects of the same type
18 have similar structures and may usually be used in the same contexts.
19 Types can overlap, and objects can belong to two or more types.
20 Consequently, we can ask whether an object belongs to a particular type,
21 but not for ``the'' type of an object.
23 @cindex primitive type
24 A few fundamental object types are built into Emacs. These, from
25 which all other types are constructed, are called @dfn{primitive types}.
26 Each object belongs to one and only one primitive type. These types
27 include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
28 @dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
29 @dfn{byte-code function}, plus several special types, such as
30 @dfn{buffer}, that are related to editing. (@xref{Editing Types}.)
32 Each primitive type has a corresponding Lisp function that checks
33 whether an object is a member of that type.
35 Lisp is unlike many other languages in that its objects are
36 @dfn{self-typing}: the primitive type of each object is implicit in
37 the object itself. For example, if an object is a vector, nothing can
38 treat it as a number; Lisp knows it is a vector, not a number.
40 In most languages, the programmer must declare the data type of each
41 variable, and the type is known by the compiler but not represented in
42 the data. Such type declarations do not exist in Emacs Lisp. A Lisp
43 variable can have any type of value, and it remembers whatever value
44 you store in it, type and all. (Actually, a small number of Emacs
45 Lisp variables can only take on values of a certain type.
46 @xref{Variables with Restricted Values}.)
48 This chapter describes the purpose, printed representation, and read
49 syntax of each of the standard types in GNU Emacs Lisp. Details on how
50 to use these types can be found in later chapters.
53 * Printed Representation:: How Lisp objects are represented as text.
54 * Comments:: Comments and their formatting conventions.
55 * Programming Types:: Types found in all Lisp systems.
56 * Editing Types:: Types specific to Emacs.
57 * Circular Objects:: Read syntax for circular structure.
58 * Type Predicates:: Tests related to types.
59 * Equality Predicates:: Tests of equality between any two objects.
62 @node Printed Representation
63 @section Printed Representation and Read Syntax
64 @cindex printed representation
67 The @dfn{printed representation} of an object is the format of the
68 output generated by the Lisp printer (the function @code{prin1}) for
69 that object. Every data type has a unique printed representation.
70 The @dfn{read syntax} of an object is the format of the input accepted
71 by the Lisp reader (the function @code{read}) for that object. This
72 is not necessarily unique; many kinds of object have more than one
73 syntax. @xref{Read and Print}.
76 In most cases, an object's printed representation is also a read
77 syntax for the object. However, some types have no read syntax, since
78 it does not make sense to enter objects of these types as constants in
79 a Lisp program. These objects are printed in @dfn{hash notation},
80 which consists of the characters @samp{#<}, a descriptive string
81 (typically the type name followed by the name of the object), and a
82 closing @samp{>}. For example:
86 @result{} #<buffer objects.texi>
90 Hash notation cannot be read at all, so the Lisp reader signals the
91 error @code{invalid-read-syntax} whenever it encounters @samp{#<}.
92 @kindex invalid-read-syntax
94 In other languages, an expression is text; it has no other form. In
95 Lisp, an expression is primarily a Lisp object and only secondarily the
96 text that is the object's read syntax. Often there is no need to
97 emphasize this distinction, but you must keep it in the back of your
98 mind, or you will occasionally be very confused.
100 When you evaluate an expression interactively, the Lisp interpreter
101 first reads the textual representation of it, producing a Lisp object,
102 and then evaluates that object (@pxref{Evaluation}). However,
103 evaluation and reading are separate activities. Reading returns the
104 Lisp object represented by the text that is read; the object may or may
105 not be evaluated later. @xref{Input Functions}, for a description of
106 @code{read}, the basic function for reading objects.
111 @cindex @samp{;} in comment
113 A @dfn{comment} is text that is written in a program only for the sake
114 of humans that read the program, and that has no effect on the meaning
115 of the program. In Lisp, a semicolon (@samp{;}) starts a comment if it
116 is not within a string or character constant. The comment continues to
117 the end of line. The Lisp reader discards comments; they do not become
118 part of the Lisp objects which represent the program within the Lisp
121 The @samp{#@@@var{count}} construct, which skips the next @var{count}
122 characters, is useful for program-generated comments containing binary
123 data. The Emacs Lisp byte compiler uses this in its output files
124 (@pxref{Byte Compilation}). It isn't meant for source files, however.
126 @xref{Comment Tips}, for conventions for formatting comments.
128 @node Programming Types
129 @section Programming Types
130 @cindex programming types
132 There are two general categories of types in Emacs Lisp: those having
133 to do with Lisp programming, and those having to do with editing. The
134 former exist in many Lisp implementations, in one form or another. The
135 latter are unique to Emacs Lisp.
138 * Integer Type:: Numbers without fractional parts.
139 * Floating-Point Type:: Numbers with fractional parts and with a large range.
140 * Character Type:: The representation of letters, numbers and
142 * Symbol Type:: A multi-use object that refers to a function,
143 variable, or property list, and has a unique identity.
144 * Sequence Type:: Both lists and arrays are classified as sequences.
145 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
146 * Array Type:: Arrays include strings and vectors.
147 * String Type:: An (efficient) array of characters.
148 * Vector Type:: One-dimensional arrays.
149 * Char-Table Type:: One-dimensional sparse arrays indexed by characters.
150 * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
151 * Hash Table Type:: Super-fast lookup tables.
152 * Function Type:: A piece of executable code you can call from elsewhere.
153 * Macro Type:: A method of expanding an expression into another
154 expression, more fundamental but less pretty.
155 * Primitive Function Type:: A function written in C, callable from Lisp.
156 * Byte-Code Type:: A function written in Lisp, then compiled.
157 * Autoload Type:: A type used for automatically loading seldom-used
159 * Finalizer Type:: Runs code when no longer reachable.
164 @subsection Integer Type
166 The range of values for an integer depends on the machine. The
167 minimum range is @minus{}536,870,912 to 536,870,911 (30 bits; i.e.,
181 but many machines provide a wider range.
182 Emacs Lisp arithmetic functions do not check for integer overflow. Thus
183 @code{(1+ 536870911)} is @minus{}536,870,912 if Emacs integers are 30 bits.
185 The read syntax for integers is a sequence of (base ten) digits with an
186 optional sign at the beginning and an optional period at the end. The
187 printed representation produced by the Lisp interpreter never has a
188 leading @samp{+} or a final @samp{.}.
192 -1 ; @r{The integer @minus{}1.}
193 1 ; @r{The integer 1.}
194 1. ; @r{Also the integer 1.}
195 +1 ; @r{Also the integer 1.}
200 As a special exception, if a sequence of digits specifies an integer
201 too large or too small to be a valid integer object, the Lisp reader
202 reads it as a floating-point number (@pxref{Floating-Point Type}).
203 For instance, if Emacs integers are 30 bits, @code{536870912} is read
204 as the floating-point number @code{536870912.0}.
206 @xref{Numbers}, for more information.
208 @node Floating-Point Type
209 @subsection Floating-Point Type
211 Floating-point numbers are the computer equivalent of scientific
212 notation; you can think of a floating-point number as a fraction
213 together with a power of ten. The precise number of significant
214 figures and the range of possible exponents is machine-specific; Emacs
215 uses the C data type @code{double} to store the value, and internally
216 this records a power of 2 rather than a power of 10.
218 The printed representation for floating-point numbers requires either
219 a decimal point (with at least one digit following), an exponent, or
220 both. For example, @samp{1500.0}, @samp{+15e2}, @samp{15.0e+2},
221 @samp{+1500000e-3}, and @samp{.15e4} are five ways of writing a floating-point
222 number whose value is 1500. They are all equivalent.
224 @xref{Numbers}, for more information.
227 @subsection Character Type
228 @cindex @acronym{ASCII} character codes
230 A @dfn{character} in Emacs Lisp is nothing more than an integer. In
231 other words, characters are represented by their character codes. For
232 example, the character @kbd{A} is represented as the @w{integer 65}.
234 Individual characters are used occasionally in programs, but it is
235 more common to work with @emph{strings}, which are sequences composed
236 of characters. @xref{String Type}.
238 Characters in strings and buffers are currently limited to the range
239 of 0 to 4194303---twenty two bits (@pxref{Character Codes}). Codes 0
240 through 127 are @acronym{ASCII} codes; the rest are
241 non-@acronym{ASCII} (@pxref{Non-ASCII Characters}). Characters that
242 represent keyboard input have a much wider range, to encode modifier
243 keys such as Control, Meta and Shift.
245 There are special functions for producing a human-readable textual
246 description of a character for the sake of messages. @xref{Describing
250 * Basic Char Syntax:: Syntax for regular characters.
251 * General Escape Syntax:: How to specify characters by their codes.
252 * Ctl-Char Syntax:: Syntax for control characters.
253 * Meta-Char Syntax:: Syntax for meta-characters.
254 * Other Char Bits:: Syntax for hyper-, super-, and alt-characters.
257 @node Basic Char Syntax
258 @subsubsection Basic Char Syntax
259 @cindex read syntax for characters
260 @cindex printed representation for characters
261 @cindex syntax for characters
262 @cindex @samp{?} in character constant
263 @cindex question mark in character constant
265 Since characters are really integers, the printed representation of
266 a character is a decimal number. This is also a possible read syntax
267 for a character, but writing characters that way in Lisp programs is
268 not clear programming. You should @emph{always} use the special read
269 syntax formats that Emacs Lisp provides for characters. These syntax
270 formats start with a question mark.
272 The usual read syntax for alphanumeric characters is a question mark
273 followed by the character; thus, @samp{?A} for the character
274 @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
280 ?Q @result{} 81 ?q @result{} 113
283 You can use the same syntax for punctuation characters, but it is
284 often a good idea to add a @samp{\} so that the Emacs commands for
285 editing Lisp code don't get confused. For example, @samp{?\(} is the
286 way to write the open-paren character. If the character is @samp{\},
287 you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.
290 @cindex bell character
294 @cindex tab (ASCII character)
302 @cindex return (ASCII character)
304 @cindex escape (ASCII character)
306 @cindex space (ASCII character)
308 You can express the characters control-g, backspace, tab, newline,
309 vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
310 @samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
311 @samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
312 (@samp{?\s} followed by a dash has a different meaning---it applies
313 the ``super'' modifier to the following character.) Thus,
316 ?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
317 ?\b @result{} 8 ; @r{backspace, @key{BS}, @kbd{C-h}}
318 ?\t @result{} 9 ; @r{tab, @key{TAB}, @kbd{C-i}}
319 ?\n @result{} 10 ; @r{newline, @kbd{C-j}}
320 ?\v @result{} 11 ; @r{vertical tab, @kbd{C-k}}
321 ?\f @result{} 12 ; @r{formfeed character, @kbd{C-l}}
322 ?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
323 ?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
324 ?\s @result{} 32 ; @r{space character, @key{SPC}}
325 ?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
326 ?\d @result{} 127 ; @r{delete character, @key{DEL}}
329 @cindex escape sequence
330 These sequences which start with backslash are also known as
331 @dfn{escape sequences}, because backslash plays the role of an
332 ``escape character''; this terminology has nothing to do with the
333 character @key{ESC}. @samp{\s} is meant for use in character
334 constants; in string constants, just write the space.
336 A backslash is allowed, and harmless, preceding any character without
337 a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
338 There is no reason to add a backslash before most characters. However,
339 you should add a backslash before any of the characters
340 @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
341 Lisp code. You can also add a backslash before whitespace characters such as
342 space, tab, newline and formfeed. However, it is cleaner to use one of
343 the easily readable escape sequences, such as @samp{\t} or @samp{\s},
344 instead of an actual whitespace character such as a tab or a space.
345 (If you do write backslash followed by a space, you should write
346 an extra space after the character constant to separate it from the
349 @node General Escape Syntax
350 @subsubsection General Escape Syntax
352 In addition to the specific escape sequences for special important
353 control characters, Emacs provides several types of escape syntax that
354 you can use to specify non-@acronym{ASCII} text characters.
356 @cindex @samp{\} in character constant
357 @cindex backslash in character constants
358 @cindex unicode character escape
359 Firstly, you can specify characters by their Unicode values.
360 @code{?\u@var{nnnn}} represents a character with Unicode code point
361 @samp{U+@var{nnnn}}, where @var{nnnn} is (by convention) a hexadecimal
362 number with exactly four digits. The backslash indicates that the
363 subsequent characters form an escape sequence, and the @samp{u}
364 specifies a Unicode escape sequence.
366 There is a slightly different syntax for specifying Unicode
367 characters with code points higher than @code{U+@var{ffff}}:
368 @code{?\U00@var{nnnnnn}} represents the character with code point
369 @samp{U+@var{nnnnnn}}, where @var{nnnnnn} is a six-digit hexadecimal
370 number. The Unicode Standard only defines code points up to
371 @samp{U+@var{10ffff}}, so if you specify a code point higher than
372 that, Emacs signals an error.
374 Secondly, you can specify characters by their hexadecimal character
375 codes. A hexadecimal escape sequence consists of a backslash,
376 @samp{x}, and the hexadecimal character code. Thus, @samp{?\x41} is
377 the character @kbd{A}, @samp{?\x1} is the character @kbd{C-a}, and
378 @code{?\xe0} is the character
383 @samp{a} with grave accent.
385 You can use any number of hex digits, so you can represent any
386 character code in this way.
388 @cindex octal character code
389 Thirdly, you can specify characters by their character code in
390 octal. An octal escape sequence consists of a backslash followed by
391 up to three octal digits; thus, @samp{?\101} for the character
392 @kbd{A}, @samp{?\001} for the character @kbd{C-a}, and @code{?\002}
393 for the character @kbd{C-b}. Only characters up to octal code 777 can
394 be specified this way.
396 These escape sequences may also be used in strings. @xref{Non-ASCII
399 @node Ctl-Char Syntax
400 @subsubsection Control-Character Syntax
402 @cindex control characters
403 Control characters can be represented using yet another read syntax.
404 This consists of a question mark followed by a backslash, caret, and the
405 corresponding non-control character, in either upper or lower case. For
406 example, both @samp{?\^I} and @samp{?\^i} are valid read syntax for the
407 character @kbd{C-i}, the character whose value is 9.
409 Instead of the @samp{^}, you can use @samp{C-}; thus, @samp{?\C-i} is
410 equivalent to @samp{?\^I} and to @samp{?\^i}:
413 ?\^I @result{} 9 ?\C-I @result{} 9
416 In strings and buffers, the only control characters allowed are those
417 that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
418 any character into a control character with @samp{C-}. The character
419 codes for these non-@acronym{ASCII} control characters include the
426 bit as well as the code for the corresponding non-control character.
427 Ordinary text terminals have no way of generating non-@acronym{ASCII}
428 control characters, but you can generate them straightforwardly using
429 X and other window systems.
431 For historical reasons, Emacs treats the @key{DEL} character as
432 the control equivalent of @kbd{?}:
435 ?\^? @result{} 127 ?\C-? @result{} 127
439 As a result, it is currently not possible to represent the character
440 @kbd{Control-?}, which is a meaningful input character under X, using
441 @samp{\C-}. It is not easy to change this, as various Lisp files refer
442 to @key{DEL} in this way.
444 For representing control characters to be found in files or strings,
445 we recommend the @samp{^} syntax; for control characters in keyboard
446 input, we prefer the @samp{C-} syntax. Which one you use does not
447 affect the meaning of the program, but may guide the understanding of
450 @node Meta-Char Syntax
451 @subsubsection Meta-Character Syntax
453 @cindex meta characters
454 A @dfn{meta character} is a character typed with the @key{META}
455 modifier key. The integer that represents such a character has the
462 bit set. We use high bits for this and other modifiers to make
463 possible a wide range of basic character codes.
472 bit attached to an @acronym{ASCII} character indicates a meta
473 character; thus, the meta characters that can fit in a string have
474 codes in the range from 128 to 255, and are the meta versions of the
475 ordinary @acronym{ASCII} characters. @xref{Strings of Events}, for
476 details about @key{META}-handling in strings.
478 The read syntax for meta characters uses @samp{\M-}. For example,
479 @samp{?\M-A} stands for @kbd{M-A}. You can use @samp{\M-} together with
480 octal character codes (see below), with @samp{\C-}, or with any other
481 syntax for a character. Thus, you can write @kbd{M-A} as @samp{?\M-A},
482 or as @samp{?\M-\101}. Likewise, you can write @kbd{C-M-b} as
483 @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
485 @node Other Char Bits
486 @subsubsection Other Character Modifier Bits
488 The case of a graphic character is indicated by its character code;
489 for example, @acronym{ASCII} distinguishes between the characters @samp{a}
490 and @samp{A}. But @acronym{ASCII} has no way to represent whether a control
491 character is upper case or lower case. Emacs uses the
498 bit to indicate that the shift key was used in typing a control
499 character. This distinction is possible only when you use X terminals
500 or other special terminals; ordinary text terminals do not report the
501 distinction. The Lisp syntax for the shift bit is @samp{\S-}; thus,
502 @samp{?\C-\S-o} or @samp{?\C-\S-O} represents the shifted-control-o
505 @cindex hyper characters
506 @cindex super characters
507 @cindex alt characters
508 The X Window System defines three other
509 @anchor{modifier bits}modifier bits that can be set
510 in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}. The syntaxes
511 for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. (Case is
512 significant in these prefixes.) Thus, @samp{?\H-\M-\A-x} represents
513 @kbd{Alt-Hyper-Meta-x}. (Note that @samp{\s} with no following @samp{-}
514 represents the space character.)
516 Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
517 for super and @math{2^{24}} for hyper.
521 bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
525 @subsection Symbol Type
527 A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The
528 symbol name serves as the printed representation of the symbol. In
529 ordinary Lisp use, with one single obarray (@pxref{Creating Symbols}),
530 a symbol's name is unique---no two symbols have the same name.
532 A symbol can serve as a variable, as a function name, or to hold a
533 property list. Or it may serve only to be distinct from all other Lisp
534 objects, so that its presence in a data structure may be recognized
535 reliably. In a given context, usually only one of these uses is
536 intended. But you can use one symbol in all of these ways,
539 A symbol whose name starts with a colon (@samp{:}) is called a
540 @dfn{keyword symbol}. These symbols automatically act as constants,
541 and are normally used only by comparing an unknown symbol with a few
542 specific alternatives. @xref{Constant Variables}.
544 @cindex @samp{\} in symbols
545 @cindex backslash in symbols
546 A symbol name can contain any characters whatever. Most symbol names
547 are written with letters, digits, and the punctuation characters
548 @samp{-+=*/}. Such names require no special punctuation; the characters
549 of the name suffice as long as the name does not look like a number.
550 (If it does, write a @samp{\} at the beginning of the name to force
551 interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}?} are
552 less often used but also require no special punctuation. Any other
553 characters may be included in a symbol's name by escaping them with a
554 backslash. In contrast to its use in strings, however, a backslash in
555 the name of a symbol simply quotes the single character that follows the
556 backslash. For example, in a string, @samp{\t} represents a tab
557 character; in the name of a symbol, however, @samp{\t} merely quotes the
558 letter @samp{t}. To have a symbol with a tab character in its name, you
559 must actually use a tab (preceded with a backslash). But it's rare to
562 @cindex CL note---case of letters
564 @b{Common Lisp note:} In Common Lisp, lower case letters are always
565 ``folded'' to upper case, unless they are explicitly escaped. In Emacs
566 Lisp, upper case and lower case letters are distinct.
569 Here are several examples of symbol names. Note that the @samp{+} in
570 the fourth example is escaped to prevent it from being read as a number.
571 This is not necessary in the sixth example because the rest of the name
572 makes it invalid as a number.
576 foo ; @r{A symbol named @samp{foo}.}
577 FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
580 1+ ; @r{A symbol named @samp{1+}}
581 ; @r{(not @samp{+1}, which is an integer).}
584 \+1 ; @r{A symbol named @samp{+1}}
585 ; @r{(not a very readable name).}
588 \(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
589 @c the @'s in this next line use up three characters, hence the
590 @c apparent misalignment of the comment.
591 +-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
592 ; @r{These characters need not be escaped.}
596 @cindex @samp{##} read syntax
598 @c This uses ``colon'' instead of a literal `:' because Info cannot
599 @c cope with a `:' in a menu
600 @cindex @samp{#@var{colon}} read syntax
603 @cindex @samp{#:} read syntax
605 As an exception to the rule that a symbol's name serves as its
606 printed representation, @samp{##} is the printed representation for an
607 interned symbol whose name is an empty string. Furthermore,
608 @samp{#:@var{foo}} is the printed representation for an uninterned
609 symbol whose name is @var{foo}. (Normally, the Lisp reader interns
610 all symbols; @pxref{Creating Symbols}.)
613 @subsection Sequence Types
615 A @dfn{sequence} is a Lisp object that represents an ordered set of
616 elements. There are two kinds of sequence in Emacs Lisp: @dfn{lists}
619 Lists are the most commonly-used sequences. A list can hold
620 elements of any type, and its length can be easily changed by adding
621 or removing elements. See the next subsection for more about lists.
623 Arrays are fixed-length sequences. They are further subdivided into
624 strings, vectors, char-tables and bool-vectors. Vectors can hold
625 elements of any type, whereas string elements must be characters, and
626 bool-vector elements must be @code{t} or @code{nil}. Char-tables are
627 like vectors except that they are indexed by any valid character code.
628 The characters in a string can have text properties like characters in
629 a buffer (@pxref{Text Properties}), but vectors do not support text
630 properties, even when their elements happen to be characters.
632 Lists, strings and the other array types also share important
633 similarities. For example, all have a length @var{l}, and all have
634 elements which can be indexed from zero to @var{l} minus one. Several
635 functions, called sequence functions, accept any kind of sequence.
636 For example, the function @code{length} reports the length of any kind
637 of sequence. @xref{Sequences Arrays Vectors}.
639 It is generally impossible to read the same sequence twice, since
640 sequences are always created anew upon reading. If you read the read
641 syntax for a sequence twice, you get two sequences with equal contents.
642 There is one exception: the empty list @code{()} always stands for the
643 same object, @code{nil}.
646 @subsection Cons Cell and List Types
647 @cindex address field of register
648 @cindex decrement field of register
651 A @dfn{cons cell} is an object that consists of two slots, called
652 the @sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} any
653 Lisp object. We also say that ``the @sc{car} of this cons cell is''
654 whatever object its @sc{car} slot currently holds, and likewise for
657 @cindex list structure
658 A @dfn{list} is a series of cons cells, linked together so that the
659 @sc{cdr} slot of each cons cell holds either the next cons cell or the
660 empty list. The empty list is actually the symbol @code{nil}.
661 @xref{Lists}, for details. Because most cons cells are used as part
662 of lists, we refer to any structure made out of cons cells as a
663 @dfn{list structure}.
667 A note to C programmers: a Lisp list thus works as a @dfn{linked list}
668 built up of cons cells. Because pointers in Lisp are implicit, we do
669 not distinguish between a cons cell slot ``holding'' a value versus
670 ``pointing to'' the value.
674 Because cons cells are so central to Lisp, we also have a word for
675 ``an object which is not a cons cell''. These objects are called
679 @cindex @samp{(@dots{})} in lists
680 The read syntax and printed representation for lists are identical, and
681 consist of a left parenthesis, an arbitrary number of elements, and a
682 right parenthesis. Here are examples of lists:
685 (A 2 "A") ; @r{A list of three elements.}
686 () ; @r{A list of no elements (the empty list).}
687 nil ; @r{A list of no elements (the empty list).}
688 ("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
689 (A ()) ; @r{A list of two elements: @code{A} and the empty list.}
690 (A nil) ; @r{Equivalent to the previous.}
691 ((A B C)) ; @r{A list of one element}
692 ; @r{(which is a list of three elements).}
695 Upon reading, each object inside the parentheses becomes an element
696 of the list. That is, a cons cell is made for each element. The
697 @sc{car} slot of the cons cell holds the element, and its @sc{cdr}
698 slot refers to the next cons cell of the list, which holds the next
699 element in the list. The @sc{cdr} slot of the last cons cell is set to
702 The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
703 original Lisp implementation ran on an @w{IBM 704} computer which
704 divided words into two parts, called the ``address'' part and the
705 ``decrement''; @sc{car} was an instruction to extract the contents of
706 the address part of a register, and @sc{cdr} an instruction to extract
707 the contents of the decrement. By contrast, ``cons cells'' are named
708 for the function @code{cons} that creates them, which in turn was named
709 for its purpose, the construction of cells.
712 * Box Diagrams:: Drawing pictures of lists.
713 * Dotted Pair Notation:: A general syntax for cons cells.
714 * Association List Type:: A specially constructed list.
718 @subsubsection Drawing Lists as Box Diagrams
719 @cindex box diagrams, for lists
720 @cindex diagrams, boxed, for lists
722 A list can be illustrated by a diagram in which the cons cells are
723 shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
724 such an illustration; unlike the textual notation, which can be
725 understood by both humans and computers, the box illustrations can be
726 understood only by humans.) This picture represents the three-element
727 list @code{(rose violet buttercup)}:
731 --- --- --- --- --- ---
732 | | |--> | | |--> | | |--> nil
733 --- --- --- --- --- ---
736 --> rose --> violet --> buttercup
740 In this diagram, each box represents a slot that can hold or refer to
741 any Lisp object. Each pair of boxes represents a cons cell. Each arrow
742 represents a reference to a Lisp object, either an atom or another cons
745 In this example, the first box, which holds the @sc{car} of the first
746 cons cell, refers to or ``holds'' @code{rose} (a symbol). The second
747 box, holding the @sc{cdr} of the first cons cell, refers to the next
748 pair of boxes, the second cons cell. The @sc{car} of the second cons
749 cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
750 @sc{cdr} of the third (and last) cons cell is @code{nil}.
752 Here is another diagram of the same list, @code{(rose violet
753 buttercup)}, sketched in a different manner:
757 --------------- ---------------- -------------------
758 | car | cdr | | car | cdr | | car | cdr |
759 | rose | o-------->| violet | o-------->| buttercup | nil |
761 --------------- ---------------- -------------------
765 @cindex @code{nil} as a list
767 A list with no elements in it is the @dfn{empty list}; it is identical
768 to the symbol @code{nil}. In other words, @code{nil} is both a symbol
771 Here is the list @code{(A ())}, or equivalently @code{(A nil)},
772 depicted with boxes and arrows:
777 | | |--> | | |--> nil
785 Here is a more complex illustration, showing the three-element list,
786 @code{((pine needles) oak maple)}, the first element of which is a
791 --- --- --- --- --- ---
792 | | |--> | | |--> | | |--> nil
793 --- --- --- --- --- ---
799 --> | | |--> | | |--> nil
807 The same list represented in the second box notation looks like this:
811 -------------- -------------- --------------
812 | car | cdr | | car | cdr | | car | cdr |
813 | o | o------->| oak | o------->| maple | nil |
815 -- | --------- -------------- --------------
818 | -------------- ----------------
819 | | car | cdr | | car | cdr |
820 ------>| pine | o------->| needles | nil |
822 -------------- ----------------
826 @node Dotted Pair Notation
827 @subsubsection Dotted Pair Notation
828 @cindex dotted pair notation
829 @cindex @samp{.} in lists
831 @dfn{Dotted pair notation} is a general syntax for cons cells that
832 represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
833 @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
834 the object @var{a} and whose @sc{cdr} is the object @var{b}. Dotted
835 pair notation is more general than list syntax because the @sc{cdr}
836 does not have to be a list. However, it is more cumbersome in cases
837 where list syntax would work. In dotted pair notation, the list
838 @samp{(1 2 3)} is written as @samp{(1 . (2 . (3 . nil)))}. For
839 @code{nil}-terminated lists, you can use either notation, but list
840 notation is usually clearer and more convenient. When printing a
841 list, the dotted pair notation is only used if the @sc{cdr} of a cons
844 Here's an example using boxes to illustrate dotted pair notation.
845 This example shows the pair @code{(rose . violet)}:
858 You can combine dotted pair notation with list notation to represent
859 conveniently a chain of cons cells with a non-@code{nil} final @sc{cdr}.
860 You write a dot after the last element of the list, followed by the
861 @sc{cdr} of the final cons cell. For example, @code{(rose violet
862 . buttercup)} is equivalent to @code{(rose . (violet . buttercup))}.
863 The object looks like this:
868 | | |--> | | |--> buttercup
876 The syntax @code{(rose .@: violet .@: buttercup)} is invalid because
877 there is nothing that it could mean. If anything, it would say to put
878 @code{buttercup} in the @sc{cdr} of a cons cell whose @sc{cdr} is already
879 used for @code{violet}.
881 The list @code{(rose violet)} is equivalent to @code{(rose . (violet))},
887 | | |--> | | |--> nil
895 Similarly, the three-element list @code{(rose violet buttercup)}
896 is equivalent to @code{(rose . (violet . (buttercup)))}.
902 --- --- --- --- --- ---
903 | | |--> | | |--> | | |--> nil
904 --- --- --- --- --- ---
907 --> rose --> violet --> buttercup
912 @node Association List Type
913 @subsubsection Association List Type
915 An @dfn{association list} or @dfn{alist} is a specially-constructed
916 list whose elements are cons cells. In each element, the @sc{car} is
917 considered a @dfn{key}, and the @sc{cdr} is considered an
918 @dfn{associated value}. (In some cases, the associated value is stored
919 in the @sc{car} of the @sc{cdr}.) Association lists are often used as
920 stacks, since it is easy to add or remove associations at the front of
926 (setq alist-of-colors
927 '((rose . red) (lily . white) (buttercup . yellow)))
931 sets the variable @code{alist-of-colors} to an alist of three elements. In the
932 first element, @code{rose} is the key and @code{red} is the value.
934 @xref{Association Lists}, for a further explanation of alists and for
935 functions that work on alists. @xref{Hash Tables}, for another kind of
936 lookup table, which is much faster for handling a large number of keys.
939 @subsection Array Type
941 An @dfn{array} is composed of an arbitrary number of slots for
942 holding or referring to other Lisp objects, arranged in a contiguous block of
943 memory. Accessing any element of an array takes approximately the same
944 amount of time. In contrast, accessing an element of a list requires
945 time proportional to the position of the element in the list. (Elements
946 at the end of a list take longer to access than elements at the
947 beginning of a list.)
949 Emacs defines four types of array: strings, vectors, bool-vectors, and
952 A string is an array of characters and a vector is an array of
953 arbitrary objects. A bool-vector can hold only @code{t} or @code{nil}.
954 These kinds of array may have any length up to the largest integer.
955 Char-tables are sparse arrays indexed by any valid character code; they
956 can hold arbitrary objects.
958 The first element of an array has index zero, the second element has
959 index 1, and so on. This is called @dfn{zero-origin} indexing. For
960 example, an array of four elements has indices 0, 1, 2, @w{and 3}. The
961 largest possible index value is one less than the length of the array.
962 Once an array is created, its length is fixed.
964 All Emacs Lisp arrays are one-dimensional. (Most other programming
965 languages support multidimensional arrays, but they are not essential;
966 you can get the same effect with nested one-dimensional arrays.) Each
967 type of array has its own read syntax; see the following sections for
970 The array type is a subset of the sequence type, and contains the
971 string type, the vector type, the bool-vector type, and the char-table
975 @subsection String Type
977 A @dfn{string} is an array of characters. Strings are used for many
978 purposes in Emacs, as can be expected in a text editor; for example, as
979 the names of Lisp symbols, as messages for the user, and to represent
980 text extracted from buffers. Strings in Lisp are constants: evaluation
981 of a string returns the same string.
983 @xref{Strings and Characters}, for functions that operate on strings.
986 * Syntax for Strings:: How to specify Lisp strings.
987 * Non-ASCII in Strings:: International characters in strings.
988 * Nonprinting Characters:: Literal unprintable characters in strings.
989 * Text Props and Strings:: Strings with text properties.
992 @node Syntax for Strings
993 @subsubsection Syntax for Strings
995 @cindex @samp{"} in strings
996 @cindex double-quote in strings
997 @cindex @samp{\} in strings
998 @cindex backslash in strings
999 The read syntax for a string is a double-quote, an arbitrary number
1000 of characters, and another double-quote, @code{"like this"}. To
1001 include a double-quote in a string, precede it with a backslash; thus,
1002 @code{"\""} is a string containing just a single double-quote
1003 character. Likewise, you can include a backslash by preceding it with
1004 another backslash, like this: @code{"this \\ is a single embedded
1007 @cindex newline in strings
1008 The newline character is not special in the read syntax for strings;
1009 if you write a new line between the double-quotes, it becomes a
1010 character in the string. But an escaped newline---one that is preceded
1011 by @samp{\}---does not become part of the string; i.e., the Lisp reader
1012 ignores an escaped newline while reading a string. An escaped space
1013 @w{@samp{\ }} is likewise ignored.
1016 "It is useful to include newlines
1017 in documentation strings,
1018 but the newline is \
1019 ignored if escaped."
1020 @result{} "It is useful to include newlines
1021 in documentation strings,
1022 but the newline is ignored if escaped."
1025 @node Non-ASCII in Strings
1026 @subsubsection Non-@acronym{ASCII} Characters in Strings
1028 There are two text representations for non-@acronym{ASCII}
1029 characters in Emacs strings: multibyte and unibyte (@pxref{Text
1030 Representations}). Roughly speaking, unibyte strings store raw bytes,
1031 while multibyte strings store human-readable text. Each character in
1032 a unibyte string is a byte, i.e., its value is between 0 and 255. By
1033 contrast, each character in a multibyte string may have a value
1034 between 0 to 4194303 (@pxref{Character Type}). In both cases,
1035 characters above 127 are non-@acronym{ASCII}.
1037 You can include a non-@acronym{ASCII} character in a string constant
1038 by writing it literally. If the string constant is read from a
1039 multibyte source, such as a multibyte buffer or string, or a file that
1040 would be visited as multibyte, then Emacs reads each
1041 non-@acronym{ASCII} character as a multibyte character and
1042 automatically makes the string a multibyte string. If the string
1043 constant is read from a unibyte source, then Emacs reads the
1044 non-@acronym{ASCII} character as unibyte, and makes the string
1047 Instead of writing a character literally into a multibyte string,
1048 you can write it as its character code using an escape sequence.
1049 @xref{General Escape Syntax}, for details about escape sequences.
1051 If you use any Unicode-style escape sequence @samp{\uNNNN} or
1052 @samp{\U00NNNNNN} in a string constant (even for an @acronym{ASCII}
1053 character), Emacs automatically assumes that it is multibyte.
1055 You can also use hexadecimal escape sequences (@samp{\x@var{n}}) and
1056 octal escape sequences (@samp{\@var{n}}) in string constants.
1057 @strong{But beware:} If a string constant contains hexadecimal or
1058 octal escape sequences, and these escape sequences all specify unibyte
1059 characters (i.e., less than 256), and there are no other literal
1060 non-@acronym{ASCII} characters or Unicode-style escape sequences in
1061 the string, then Emacs automatically assumes that it is a unibyte
1062 string. That is to say, it assumes that all non-@acronym{ASCII}
1063 characters occurring in the string are 8-bit raw bytes.
1065 In hexadecimal and octal escape sequences, the escaped character
1066 code may contain a variable number of digits, so the first subsequent
1067 character which is not a valid hexadecimal or octal digit terminates
1068 the escape sequence. If the next character in a string could be
1069 interpreted as a hexadecimal or octal digit, write @w{@samp{\ }}
1070 (backslash and space) to terminate the escape sequence. For example,
1071 @w{@samp{\xe0\ }} represents one character, @samp{a} with grave
1072 accent. @w{@samp{\ }} in a string constant is just like
1073 backslash-newline; it does not contribute any character to the string,
1074 but it does terminate any preceding hex escape.
1076 @node Nonprinting Characters
1077 @subsubsection Nonprinting Characters in Strings
1079 You can use the same backslash escape-sequences in a string constant
1080 as in character literals (but do not use the question mark that begins a
1081 character constant). For example, you can write a string containing the
1082 nonprinting characters tab and @kbd{C-a}, with commas and spaces between
1083 them, like this: @code{"\t, \C-a"}. @xref{Character Type}, for a
1084 description of the read syntax for characters.
1086 However, not all of the characters you can write with backslash
1087 escape-sequences are valid in strings. The only control characters that
1088 a string can hold are the @acronym{ASCII} control characters. Strings do not
1089 distinguish case in @acronym{ASCII} control characters.
1091 Properly speaking, strings cannot hold meta characters; but when a
1092 string is to be used as a key sequence, there is a special convention
1093 that provides a way to represent meta versions of @acronym{ASCII}
1094 characters in a string. If you use the @samp{\M-} syntax to indicate
1095 a meta character in a string constant, this sets the
1102 bit of the character in the string. If the string is used in
1103 @code{define-key} or @code{lookup-key}, this numeric code is translated
1104 into the equivalent meta character. @xref{Character Type}.
1106 Strings cannot hold characters that have the hyper, super, or alt
1109 @node Text Props and Strings
1110 @subsubsection Text Properties in Strings
1112 @cindex @samp{#(} read syntax
1113 @cindex text properties, read syntax
1114 A string can hold properties for the characters it contains, in
1115 addition to the characters themselves. This enables programs that copy
1116 text between strings and buffers to copy the text's properties with no
1117 special effort. @xref{Text Properties}, for an explanation of what text
1118 properties mean. Strings with text properties use a special read and
1122 #("@var{characters}" @var{property-data}...)
1126 where @var{property-data} consists of zero or more elements, in groups
1127 of three as follows:
1130 @var{beg} @var{end} @var{plist}
1134 The elements @var{beg} and @var{end} are integers, and together specify
1135 a range of indices in the string; @var{plist} is the property list for
1136 that range. For example,
1139 #("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))
1143 represents a string whose textual contents are @samp{foo bar}, in which
1144 the first three characters have a @code{face} property with value
1145 @code{bold}, and the last three have a @code{face} property with value
1146 @code{italic}. (The fourth character has no text properties, so its
1147 property list is @code{nil}. It is not actually necessary to mention
1148 ranges with @code{nil} as the property list, since any characters not
1149 mentioned in any range will default to having no properties.)
1152 @subsection Vector Type
1154 A @dfn{vector} is a one-dimensional array of elements of any type. It
1155 takes a constant amount of time to access any element of a vector. (In
1156 a list, the access time of an element is proportional to the distance of
1157 the element from the beginning of the list.)
1159 The printed representation of a vector consists of a left square
1160 bracket, the elements, and a right square bracket. This is also the
1161 read syntax. Like numbers and strings, vectors are considered constants
1165 [1 "two" (three)] ; @r{A vector of three elements.}
1166 @result{} [1 "two" (three)]
1169 @xref{Vectors}, for functions that work with vectors.
1171 @node Char-Table Type
1172 @subsection Char-Table Type
1174 A @dfn{char-table} is a one-dimensional array of elements of any type,
1175 indexed by character codes. Char-tables have certain extra features to
1176 make them more useful for many jobs that involve assigning information
1177 to character codes---for example, a char-table can have a parent to
1178 inherit from, a default value, and a small number of extra slots to use for
1179 special purposes. A char-table can also specify a single value for
1180 a whole character set.
1182 @cindex @samp{#^} read syntax
1183 The printed representation of a char-table is like a vector
1184 except that there is an extra @samp{#^} at the beginning.@footnote{You
1185 may also encounter @samp{#^^}, used for ``sub-char-tables''.}
1187 @xref{Char-Tables}, for special functions to operate on char-tables.
1188 Uses of char-tables include:
1192 Case tables (@pxref{Case Tables}).
1195 Character category tables (@pxref{Categories}).
1198 Display tables (@pxref{Display Tables}).
1201 Syntax tables (@pxref{Syntax Tables}).
1204 @node Bool-Vector Type
1205 @subsection Bool-Vector Type
1207 A @dfn{bool-vector} is a one-dimensional array whose elements must
1208 be @code{t} or @code{nil}.
1210 The printed representation of a bool-vector is like a string, except
1211 that it begins with @samp{#&} followed by the length. The string
1212 constant that follows actually specifies the contents of the bool-vector
1213 as a bitmap---each ``character'' in the string contains 8 bits, which
1214 specify the next 8 elements of the bool-vector (1 stands for @code{t},
1215 and 0 for @code{nil}). The least significant bits of the character
1216 correspond to the lowest indices in the bool-vector.
1219 (make-bool-vector 3 t)
1221 (make-bool-vector 3 nil)
1226 These results make sense, because the binary code for @samp{C-g} is
1227 111 and @samp{C-@@} is the character with code 0.
1229 If the length is not a multiple of 8, the printed representation
1230 shows extra elements, but these extras really make no difference. For
1231 instance, in the next example, the two bool-vectors are equal, because
1232 only the first 3 bits are used:
1235 (equal #&3"\377" #&3"\007")
1239 @node Hash Table Type
1240 @subsection Hash Table Type
1242 A hash table is a very fast kind of lookup table, somewhat like an
1243 alist in that it maps keys to corresponding values, but much faster.
1244 The printed representation of a hash table specifies its properties
1245 and contents, like this:
1249 @result{} #s(hash-table size 65 test eql rehash-size 1.5
1250 rehash-threshold 0.8 data ())
1254 @xref{Hash Tables}, for more information about hash tables.
1257 @subsection Function Type
1259 Lisp functions are executable code, just like functions in other
1260 programming languages. In Lisp, unlike most languages, functions are
1261 also Lisp objects. A non-compiled function in Lisp is a lambda
1262 expression: that is, a list whose first element is the symbol
1263 @code{lambda} (@pxref{Lambda Expressions}).
1265 In most programming languages, it is impossible to have a function
1266 without a name. In Lisp, a function has no intrinsic name. A lambda
1267 expression can be called as a function even though it has no name; to
1268 emphasize this, we also call it an @dfn{anonymous function}
1269 (@pxref{Anonymous Functions}). A named function in Lisp is just a
1270 symbol with a valid function in its function cell (@pxref{Defining
1273 Most of the time, functions are called when their names are written in
1274 Lisp expressions in Lisp programs. However, you can construct or obtain
1275 a function object at run time and then call it with the primitive
1276 functions @code{funcall} and @code{apply}. @xref{Calling Functions}.
1279 @subsection Macro Type
1281 A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
1282 language. It is represented as an object much like a function, but with
1283 different argument-passing semantics. A Lisp macro has the form of a
1284 list whose first element is the symbol @code{macro} and whose @sc{cdr}
1285 is a Lisp function object, including the @code{lambda} symbol.
1287 Lisp macro objects are usually defined with the built-in
1288 @code{defmacro} function, but any list that begins with @code{macro} is
1289 a macro as far as Emacs is concerned. @xref{Macros}, for an explanation
1290 of how to write a macro.
1292 @strong{Warning}: Lisp macros and keyboard macros (@pxref{Keyboard
1293 Macros}) are entirely different things. When we use the word ``macro''
1294 without qualification, we mean a Lisp macro, not a keyboard macro.
1296 @node Primitive Function Type
1297 @subsection Primitive Function Type
1298 @cindex primitive function
1300 A @dfn{primitive function} is a function callable from Lisp but
1301 written in the C programming language. Primitive functions are also
1302 called @dfn{subrs} or @dfn{built-in functions}. (The word ``subr'' is
1303 derived from ``subroutine''.) Most primitive functions evaluate all
1304 their arguments when they are called. A primitive function that does
1305 not evaluate all its arguments is called a @dfn{special form}
1306 (@pxref{Special Forms}).
1308 It does not matter to the caller of a function whether the function is
1309 primitive. However, this does matter if you try to redefine a primitive
1310 with a function written in Lisp. The reason is that the primitive
1311 function may be called directly from C code. Calls to the redefined
1312 function from Lisp will use the new definition, but calls from C code
1313 may still use the built-in definition. Therefore, @strong{we discourage
1314 redefinition of primitive functions}.
1316 The term @dfn{function} refers to all Emacs functions, whether written
1317 in Lisp or C@. @xref{Function Type}, for information about the
1318 functions written in Lisp.
1320 Primitive functions have no read syntax and print in hash notation
1321 with the name of the subroutine.
1325 (symbol-function 'car) ; @r{Access the function cell}
1326 ; @r{of the symbol.}
1327 @result{} #<subr car>
1328 (subrp (symbol-function 'car)) ; @r{Is this a primitive function?}
1329 @result{} t ; @r{Yes.}
1333 @node Byte-Code Type
1334 @subsection Byte-Code Function Type
1336 @dfn{Byte-code function objects} are produced by byte-compiling Lisp
1337 code (@pxref{Byte Compilation}). Internally, a byte-code function
1338 object is much like a vector; however, the evaluator handles this data
1339 type specially when it appears in a function call. @xref{Byte-Code
1342 The printed representation and read syntax for a byte-code function
1343 object is like that for a vector, with an additional @samp{#} before the
1347 @subsection Autoload Type
1349 An @dfn{autoload object} is a list whose first element is the symbol
1350 @code{autoload}. It is stored as the function definition of a symbol,
1351 where it serves as a placeholder for the real definition. The autoload
1352 object says that the real definition is found in a file of Lisp code
1353 that should be loaded when necessary. It contains the name of the file,
1354 plus some other information about the real definition.
1356 After the file has been loaded, the symbol should have a new function
1357 definition that is not an autoload object. The new definition is then
1358 called as if it had been there to begin with. From the user's point of
1359 view, the function call works as expected, using the function definition
1362 An autoload object is usually created with the function
1363 @code{autoload}, which stores the object in the function cell of a
1364 symbol. @xref{Autoload}, for more details.
1366 @node Finalizer Type
1367 @subsection Finalizer Type
1369 A @dfn{finalizer object} helps Lisp code clean up after objects that
1370 are no longer needed. A finalizer holds a Lisp function object.
1371 When a finalizer object becomes unreachable after a garbage collection
1372 pass, Emacs calls the finalizer's associated function object.
1373 When deciding whether a finalizer is reachable, Emacs does not count
1374 references from finalizer objects themselves, allowing you to use
1375 finalizers without having to worry about accidentally capturing
1376 references to finalized objects themselves.
1378 Errors in finalizers are printed to @code{*Messages*}. Emacs runs
1379 a given finalizer object's associated function exactly once, even
1380 if that function fails.
1382 @defun make-finalizer function
1383 Make a finalizer that will run @var{function}. @var{function} will be
1384 called after garbage collection when the returned finalizer object
1385 becomes unreachable. If the finalizer object is reachable only
1386 through references from finalizer objects, it does not count as
1387 reachable for the purpose of deciding whether to run @var{function}.
1388 @var{function} will be run once per finalizer object.
1392 @section Editing Types
1393 @cindex editing types
1395 The types in the previous section are used for general programming
1396 purposes, and most of them are common to most Lisp dialects. Emacs Lisp
1397 provides several additional data types for purposes connected with
1401 * Buffer Type:: The basic object of editing.
1402 * Marker Type:: A position in a buffer.
1403 * Window Type:: Buffers are displayed in windows.
1404 * Frame Type:: Windows subdivide frames.
1405 * Terminal Type:: A terminal device displays frames.
1406 * Window Configuration Type:: Recording the way a frame is subdivided.
1407 * Frame Configuration Type:: Recording the status of all frames.
1408 * Process Type:: A subprocess of Emacs running on the underlying OS.
1409 * Stream Type:: Receive or send characters.
1410 * Keymap Type:: What function a keystroke invokes.
1411 * Overlay Type:: How an overlay is represented.
1412 * Font Type:: Fonts for displaying text.
1416 @subsection Buffer Type
1418 A @dfn{buffer} is an object that holds text that can be edited
1419 (@pxref{Buffers}). Most buffers hold the contents of a disk file
1420 (@pxref{Files}) so they can be edited, but some are used for other
1421 purposes. Most buffers are also meant to be seen by the user, and
1422 therefore displayed, at some time, in a window (@pxref{Windows}). But
1423 a buffer need not be displayed in any window. Each buffer has a
1424 designated position called @dfn{point} (@pxref{Positions}); most
1425 editing commands act on the contents of the current buffer in the
1426 neighborhood of point. At any time, one buffer is the @dfn{current
1429 The contents of a buffer are much like a string, but buffers are not
1430 used like strings in Emacs Lisp, and the available operations are
1431 different. For example, you can insert text efficiently into an
1432 existing buffer, altering the buffer's contents, whereas ``inserting''
1433 text into a string requires concatenating substrings, and the result
1434 is an entirely new string object.
1436 Many of the standard Emacs functions manipulate or test the
1437 characters in the current buffer; a whole chapter in this manual is
1438 devoted to describing these functions (@pxref{Text}).
1440 Several other data structures are associated with each buffer:
1444 a local syntax table (@pxref{Syntax Tables});
1447 a local keymap (@pxref{Keymaps}); and,
1450 a list of buffer-local variable bindings (@pxref{Buffer-Local Variables}).
1453 overlays (@pxref{Overlays}).
1456 text properties for the text in the buffer (@pxref{Text Properties}).
1460 The local keymap and variable list contain entries that individually
1461 override global bindings or values. These are used to customize the
1462 behavior of programs in different buffers, without actually changing the
1465 A buffer may be @dfn{indirect}, which means it shares the text
1466 of another buffer, but presents it differently. @xref{Indirect Buffers}.
1468 Buffers have no read syntax. They print in hash notation, showing the
1474 @result{} #<buffer objects.texi>
1479 @subsection Marker Type
1481 A @dfn{marker} denotes a position in a specific buffer. Markers
1482 therefore have two components: one for the buffer, and one for the
1483 position. Changes in the buffer's text automatically relocate the
1484 position value as necessary to ensure that the marker always points
1485 between the same two characters in the buffer.
1487 Markers have no read syntax. They print in hash notation, giving the
1488 current character position and the name of the buffer.
1493 @result{} #<marker at 10779 in objects.texi>
1497 @xref{Markers}, for information on how to test, create, copy, and move
1501 @subsection Window Type
1503 A @dfn{window} describes the portion of the terminal screen that Emacs
1504 uses to display a buffer. Every window has one associated buffer, whose
1505 contents appear in the window. By contrast, a given buffer may appear
1506 in one window, no window, or several windows.
1508 Though many windows may exist simultaneously, at any time one window
1509 is designated the @dfn{selected window}. This is the window where the
1510 cursor is (usually) displayed when Emacs is ready for a command. The
1511 selected window usually displays the current buffer, but this is not
1512 necessarily the case.
1514 Windows are grouped on the screen into frames; each window belongs to
1515 one and only one frame. @xref{Frame Type}.
1517 Windows have no read syntax. They print in hash notation, giving the
1518 window number and the name of the buffer being displayed. The window
1519 numbers exist to identify windows uniquely, since the buffer displayed
1520 in any given window can change frequently.
1525 @result{} #<window 1 on objects.texi>
1529 @xref{Windows}, for a description of the functions that work on windows.
1532 @subsection Frame Type
1534 A @dfn{frame} is a screen area that contains one or more Emacs
1535 windows; we also use the term ``frame'' to refer to the Lisp object
1536 that Emacs uses to refer to the screen area.
1538 Frames have no read syntax. They print in hash notation, giving the
1539 frame's title, plus its address in core (useful to identify the frame
1545 @result{} #<frame emacs@@psilocin.gnu.org 0xdac80>
1549 @xref{Frames}, for a description of the functions that work on frames.
1552 @subsection Terminal Type
1553 @cindex terminal type
1555 A @dfn{terminal} is a device capable of displaying one or more
1556 Emacs frames (@pxref{Frame Type}).
1558 Terminals have no read syntax. They print in hash notation giving
1559 the terminal's ordinal number and its TTY device file name.
1563 (get-device-terminal nil)
1564 @result{} #<terminal 1 on /dev/tty>
1568 @c FIXME: add an xref to where terminal-related primitives are described.
1570 @node Window Configuration Type
1571 @subsection Window Configuration Type
1572 @cindex window layout in a frame
1574 A @dfn{window configuration} stores information about the positions,
1575 sizes, and contents of the windows in a frame, so you can recreate the
1576 same arrangement of windows later.
1578 Window configurations do not have a read syntax; their print syntax
1579 looks like @samp{#<window-configuration>}. @xref{Window
1580 Configurations}, for a description of several functions related to
1581 window configurations.
1583 @node Frame Configuration Type
1584 @subsection Frame Configuration Type
1585 @cindex screen layout
1586 @cindex window layout, all frames
1588 A @dfn{frame configuration} stores information about the positions,
1589 sizes, and contents of the windows in all frames. It is not a
1590 primitive type---it is actually a list whose @sc{car} is
1591 @code{frame-configuration} and whose @sc{cdr} is an alist. Each alist
1592 element describes one frame, which appears as the @sc{car} of that
1595 @xref{Frame Configurations}, for a description of several functions
1596 related to frame configurations.
1599 @subsection Process Type
1601 The word @dfn{process} usually means a running program. Emacs itself
1602 runs in a process of this sort. However, in Emacs Lisp, a process is a
1603 Lisp object that designates a subprocess created by the Emacs process.
1604 Programs such as shells, GDB, ftp, and compilers, running in
1605 subprocesses of Emacs, extend the capabilities of Emacs.
1606 An Emacs subprocess takes textual input from Emacs and returns textual
1607 output to Emacs for further manipulation. Emacs can also send signals
1610 Process objects have no read syntax. They print in hash notation,
1611 giving the name of the process:
1616 @result{} (#<process shell>)
1620 @xref{Processes}, for information about functions that create, delete,
1621 return information about, send input or signals to, and receive output
1625 @subsection Stream Type
1627 A @dfn{stream} is an object that can be used as a source or sink for
1628 characters---either to supply characters for input or to accept them as
1629 output. Many different types can be used this way: markers, buffers,
1630 strings, and functions. Most often, input streams (character sources)
1631 obtain characters from the keyboard, a buffer, or a file, and output
1632 streams (character sinks) send characters to a buffer, such as a
1633 @file{*Help*} buffer, or to the echo area.
1635 The object @code{nil}, in addition to its other meanings, may be used
1636 as a stream. It stands for the value of the variable
1637 @code{standard-input} or @code{standard-output}. Also, the object
1638 @code{t} as a stream specifies input using the minibuffer
1639 (@pxref{Minibuffers}) or output in the echo area (@pxref{The Echo
1642 Streams have no special printed representation or read syntax, and
1643 print as whatever primitive type they are.
1645 @xref{Read and Print}, for a description of functions
1646 related to streams, including parsing and printing functions.
1649 @subsection Keymap Type
1651 A @dfn{keymap} maps keys typed by the user to commands. This mapping
1652 controls how the user's command input is executed. A keymap is actually
1653 a list whose @sc{car} is the symbol @code{keymap}.
1655 @xref{Keymaps}, for information about creating keymaps, handling prefix
1656 keys, local as well as global keymaps, and changing key bindings.
1659 @subsection Overlay Type
1661 An @dfn{overlay} specifies properties that apply to a part of a
1662 buffer. Each overlay applies to a specified range of the buffer, and
1663 contains a property list (a list whose elements are alternating property
1664 names and values). Overlay properties are used to present parts of the
1665 buffer temporarily in a different display style. Overlays have no read
1666 syntax, and print in hash notation, giving the buffer name and range of
1669 @xref{Overlays}, for information on how you can create and use overlays.
1672 @subsection Font Type
1674 A @dfn{font} specifies how to display text on a graphical terminal.
1675 There are actually three separate font types---@dfn{font objects},
1676 @dfn{font specs}, and @dfn{font entities}---each of which has slightly
1677 different properties. None of them have a read syntax; their print
1678 syntax looks like @samp{#<font-object>}, @samp{#<font-spec>}, and
1679 @samp{#<font-entity>} respectively. @xref{Low-Level Font}, for a
1680 description of these Lisp objects.
1682 @node Circular Objects
1683 @section Read Syntax for Circular Objects
1684 @cindex circular structure, read syntax
1685 @cindex shared structure, read syntax
1686 @cindex @samp{#@var{n}=} read syntax
1687 @cindex @samp{#@var{n}#} read syntax
1689 To represent shared or circular structures within a complex of Lisp
1690 objects, you can use the reader constructs @samp{#@var{n}=} and
1693 Use @code{#@var{n}=} before an object to label it for later reference;
1694 subsequently, you can use @code{#@var{n}#} to refer the same object in
1695 another place. Here, @var{n} is some integer. For example, here is how
1696 to make a list in which the first element recurs as the third element:
1703 This differs from ordinary syntax such as this
1710 which would result in a list whose first and third elements
1711 look alike but are not the same Lisp object. This shows the difference:
1715 (setq x '(#1=(a) b #1#)))
1716 (eq (nth 0 x) (nth 2 x))
1718 (setq x '((a) b (a)))
1719 (eq (nth 0 x) (nth 2 x))
1723 You can also use the same syntax to make a circular structure, which
1724 appears as an ``element'' within itself. Here is an example:
1731 This makes a list whose second element is the list itself.
1732 Here's how you can see that it really works:
1736 (setq x '#1=(a #1#)))
1741 The Lisp printer can produce this syntax to record circular and shared
1742 structure in a Lisp object, if you bind the variable @code{print-circle}
1743 to a non-@code{nil} value. @xref{Output Variables}.
1745 @node Type Predicates
1746 @section Type Predicates
1747 @cindex type checking
1748 @kindex wrong-type-argument
1750 The Emacs Lisp interpreter itself does not perform type checking on
1751 the actual arguments passed to functions when they are called. It could
1752 not do so, since function arguments in Lisp do not have declared data
1753 types, as they do in other programming languages. It is therefore up to
1754 the individual function to test whether each actual argument belongs to
1755 a type that the function can use.
1757 All built-in functions do check the types of their actual arguments
1758 when appropriate, and signal a @code{wrong-type-argument} error if an
1759 argument is of the wrong type. For example, here is what happens if you
1760 pass an argument to @code{+} that it cannot handle:
1765 @error{} Wrong type argument: number-or-marker-p, a
1769 @cindex type predicates
1770 @cindex testing types
1771 If you want your program to handle different types differently, you
1772 must do explicit type checking. The most common way to check the type
1773 of an object is to call a @dfn{type predicate} function. Emacs has a
1774 type predicate for each type, as well as some predicates for
1775 combinations of types.
1777 A type predicate function takes one argument; it returns @code{t} if
1778 the argument belongs to the appropriate type, and @code{nil} otherwise.
1779 Following a general Lisp convention for predicate functions, most type
1780 predicates' names end with @samp{p}.
1782 Here is an example which uses the predicates @code{listp} to check for
1783 a list and @code{symbolp} to check for a symbol.
1788 ;; If X is a symbol, put it on LIST.
1789 (setq list (cons x list)))
1791 ;; If X is a list, add its elements to LIST.
1792 (setq list (append x list)))
1794 ;; We handle only symbols and lists.
1795 (error "Invalid argument %s in add-on" x))))
1798 Here is a table of predefined type predicates, in alphabetical order,
1799 with references to further information.
1803 @xref{List-related Predicates, atom}.
1806 @xref{Array Functions, arrayp}.
1809 @xref{Bool-Vectors, bool-vector-p}.
1812 @xref{Buffer Basics, bufferp}.
1814 @item byte-code-function-p
1815 @xref{Byte-Code Type, byte-code-function-p}.
1818 @xref{Case Tables, case-table-p}.
1820 @item char-or-string-p
1821 @xref{Predicates for Strings, char-or-string-p}.
1824 @xref{Char-Tables, char-table-p}.
1827 @xref{Interactive Call, commandp}.
1830 @xref{List-related Predicates, consp}.
1832 @item custom-variable-p
1833 @xref{Variable Definitions, custom-variable-p}.
1836 @xref{Predicates on Numbers, floatp}.
1839 @xref{Low-Level Font}.
1841 @item frame-configuration-p
1842 @xref{Frame Configurations, frame-configuration-p}.
1845 @xref{Deleting Frames, frame-live-p}.
1848 @xref{Frames, framep}.
1851 @xref{Functions, functionp}.
1854 @xref{Other Hash, hash-table-p}.
1856 @item integer-or-marker-p
1857 @xref{Predicates on Markers, integer-or-marker-p}.
1860 @xref{Predicates on Numbers, integerp}.
1863 @xref{Creating Keymaps, keymapp}.
1866 @xref{Constant Variables}.
1869 @xref{List-related Predicates, listp}.
1872 @xref{Predicates on Markers, markerp}.
1875 @xref{Predicates on Numbers, wholenump}.
1878 @xref{List-related Predicates, nlistp}.
1881 @xref{Predicates on Numbers, numberp}.
1883 @item number-or-marker-p
1884 @xref{Predicates on Markers, number-or-marker-p}.
1887 @xref{Overlays, overlayp}.
1890 @xref{Processes, processp}.
1893 @xref{Sequence Functions, sequencep}.
1896 @xref{Predicates for Strings, stringp}.
1899 @xref{Function Cells, subrp}.
1902 @xref{Symbols, symbolp}.
1904 @item syntax-table-p
1905 @xref{Syntax Tables, syntax-table-p}.
1908 @xref{Vectors, vectorp}.
1910 @item window-configuration-p
1911 @xref{Window Configurations, window-configuration-p}.
1914 @xref{Deleting Windows, window-live-p}.
1917 @xref{Basic Windows, windowp}.
1920 @xref{nil and t, booleanp}.
1922 @item string-or-null-p
1923 @xref{Predicates for Strings, string-or-null-p}.
1926 The most general way to check the type of an object is to call the
1927 function @code{type-of}. Recall that each object belongs to one and
1928 only one primitive type; @code{type-of} tells you which one (@pxref{Lisp
1929 Data Types}). But @code{type-of} knows nothing about non-primitive
1930 types. In most cases, it is more convenient to use type predicates than
1933 @defun type-of object
1934 This function returns a symbol naming the primitive type of
1935 @var{object}. The value is one of the symbols @code{bool-vector},
1936 @code{buffer}, @code{char-table}, @code{compiled-function},
1937 @code{cons}, @code{finalizer}, @code{float}, @code{font-entity},
1938 @code{font-object}, @code{font-spec}, @code{frame}, @code{hash-table},
1939 @code{integer}, @code{marker}, @code{overlay}, @code{process},
1940 @code{string}, @code{subr}, @code{symbol}, @code{vector},
1941 @code{window}, or @code{window-configuration}.
1949 (type-of '()) ; @r{@code{()} is @code{nil}.}
1957 @node Equality Predicates
1958 @section Equality Predicates
1961 Here we describe functions that test for equality between two
1962 objects. Other functions test equality of contents between objects of
1963 specific types, e.g., strings. For these predicates, see the
1964 appropriate chapter describing the data type.
1966 @defun eq object1 object2
1967 This function returns @code{t} if @var{object1} and @var{object2} are
1968 the same object, and @code{nil} otherwise.
1970 If @var{object1} and @var{object2} are integers with the same value,
1971 they are considered to be the same object (i.e., @code{eq} returns
1972 @code{t}). If @var{object1} and @var{object2} are symbols with the
1973 same name, they are normally the same object---but see @ref{Creating
1974 Symbols} for exceptions. For other types (e.g., lists, vectors,
1975 strings), two arguments with the same contents or elements are not
1976 necessarily @code{eq} to each other: they are @code{eq} only if they
1977 are the same object, meaning that a change in the contents of one will
1978 be reflected by the same change in the contents of the other.
1999 ;; @r{This exception occurs because Emacs Lisp}
2000 ;; @r{makes just one multibyte empty string, to save space.}
2004 (eq '(1 (2 (3))) '(1 (2 (3))))
2009 (setq foo '(1 (2 (3))))
2010 @result{} (1 (2 (3)))
2013 (eq foo '(1 (2 (3))))
2018 (eq [(1 2) 3] [(1 2) 3])
2023 (eq (point-marker) (point-marker))
2029 The @code{make-symbol} function returns an uninterned symbol, distinct
2030 from the symbol that is used if you write the name in a Lisp expression.
2031 Distinct symbols with the same name are not @code{eq}. @xref{Creating
2036 (eq (make-symbol "foo") 'foo)
2042 @defun equal object1 object2
2043 This function returns @code{t} if @var{object1} and @var{object2} have
2044 equal components, and @code{nil} otherwise. Whereas @code{eq} tests
2045 if its arguments are the same object, @code{equal} looks inside
2046 nonidentical arguments to see if their elements or contents are the
2047 same. So, if two objects are @code{eq}, they are @code{equal}, but
2048 the converse is not always true.
2062 (equal "asdf" "asdf")
2071 (equal '(1 (2 (3))) '(1 (2 (3))))
2075 (eq '(1 (2 (3))) '(1 (2 (3))))
2080 (equal [(1 2) 3] [(1 2) 3])
2084 (eq [(1 2) 3] [(1 2) 3])
2089 (equal (point-marker) (point-marker))
2094 (eq (point-marker) (point-marker))
2099 Comparison of strings is case-sensitive, but does not take account of
2100 text properties---it compares only the characters in the strings.
2101 @xref{Text Properties}. Use @code{equal-including-properties} to also
2102 compare text properties. For technical reasons, a unibyte string and
2103 a multibyte string are @code{equal} if and only if they contain the
2104 same sequence of character codes and all these codes are either in the
2105 range 0 through 127 (@acronym{ASCII}) or 160 through 255
2106 (@code{eight-bit-graphic}). (@pxref{Text Representations}).
2110 (equal "asdf" "ASDF")
2115 However, two distinct buffers are never considered @code{equal}, even if
2116 their textual contents are the same.
2119 The test for equality is implemented recursively; for example, given
2120 two cons cells @var{x} and @var{y}, @code{(equal @var{x} @var{y})}
2121 returns @code{t} if and only if both the expressions below return
2125 (equal (car @var{x}) (car @var{y}))
2126 (equal (cdr @var{x}) (cdr @var{y}))
2129 Because of this recursive method, circular lists may therefore cause
2130 infinite recursion (leading to an error).
2132 @defun equal-including-properties object1 object2
2133 This function behaves like @code{equal} in all cases but also requires
2134 that for two strings to be equal, they have the same text properties.
2138 (equal "asdf" (propertize "asdf" '(asdf t)))
2142 (equal-including-properties "asdf"
2143 (propertize "asdf" '(asdf t)))