2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001,
4 @c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 @c Free Software Foundation, Inc.
6 @c See the file elisp.texi for copying conditions.
7 @setfilename ../../info/objects
8 @node Lisp Data Types, Numbers, Introduction, Top
9 @chapter Lisp Data Types
15 A Lisp @dfn{object} is a piece of data used and manipulated by Lisp
16 programs. For our purposes, a @dfn{type} or @dfn{data type} is a set of
19 Every object belongs to at least one type. Objects of the same type
20 have similar structures and may usually be used in the same contexts.
21 Types can overlap, and objects can belong to two or more types.
22 Consequently, we can ask whether an object belongs to a particular type,
23 but not for ``the'' type of an object.
25 @cindex primitive type
26 A few fundamental object types are built into Emacs. These, from
27 which all other types are constructed, are called @dfn{primitive types}.
28 Each object belongs to one and only one primitive type. These types
29 include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
30 @dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
31 @dfn{byte-code function}, plus several special types, such as
32 @dfn{buffer}, that are related to editing. (@xref{Editing Types}.)
34 Each primitive type has a corresponding Lisp function that checks
35 whether an object is a member of that type.
37 Lisp is unlike many other languages in that its objects are
38 @dfn{self-typing}: the primitive type of each object is implicit in
39 the object itself. For example, if an object is a vector, nothing can
40 treat it as a number; Lisp knows it is a vector, not a number.
42 In most languages, the programmer must declare the data type of each
43 variable, and the type is known by the compiler but not represented in
44 the data. Such type declarations do not exist in Emacs Lisp. A Lisp
45 variable can have any type of value, and it remembers whatever value
46 you store in it, type and all. (Actually, a small number of Emacs
47 Lisp variables can only take on values of a certain type.
48 @xref{Variables with Restricted Values}.)
50 This chapter describes the purpose, printed representation, and read
51 syntax of each of the standard types in GNU Emacs Lisp. Details on how
52 to use these types can be found in later chapters.
55 * Printed Representation:: How Lisp objects are represented as text.
56 * Comments:: Comments and their formatting conventions.
57 * Programming Types:: Types found in all Lisp systems.
58 * Editing Types:: Types specific to Emacs.
59 * Circular Objects:: Read syntax for circular structure.
60 * Type Predicates:: Tests related to types.
61 * Equality Predicates:: Tests of equality between any two objects.
64 @node Printed Representation
65 @comment node-name, next, previous, up
66 @section Printed Representation and Read Syntax
67 @cindex printed representation
70 The @dfn{printed representation} of an object is the format of the
71 output generated by the Lisp printer (the function @code{prin1}) for
72 that object. Every data type has a unique printed representation.
73 The @dfn{read syntax} of an object is the format of the input accepted
74 by the Lisp reader (the function @code{read}) for that object. This
75 is not necessarily unique; many kinds of object have more than one
76 syntax. @xref{Read and Print}.
79 In most cases, an object's printed representation is also a read
80 syntax for the object. However, some types have no read syntax, since
81 it does not make sense to enter objects of these types as constants in
82 a Lisp program. These objects are printed in @dfn{hash notation},
83 which consists of the characters @samp{#<}, a descriptive string
84 (typically the type name followed by the name of the object), and a
85 closing @samp{>}. For example:
89 @result{} #<buffer objects.texi>
93 Hash notation cannot be read at all, so the Lisp reader signals the
94 error @code{invalid-read-syntax} whenever it encounters @samp{#<}.
95 @kindex invalid-read-syntax
97 In other languages, an expression is text; it has no other form. In
98 Lisp, an expression is primarily a Lisp object and only secondarily the
99 text that is the object's read syntax. Often there is no need to
100 emphasize this distinction, but you must keep it in the back of your
101 mind, or you will occasionally be very confused.
103 When you evaluate an expression interactively, the Lisp interpreter
104 first reads the textual representation of it, producing a Lisp object,
105 and then evaluates that object (@pxref{Evaluation}). However,
106 evaluation and reading are separate activities. Reading returns the
107 Lisp object represented by the text that is read; the object may or may
108 not be evaluated later. @xref{Input Functions}, for a description of
109 @code{read}, the basic function for reading objects.
112 @comment node-name, next, previous, up
115 @cindex @samp{;} in comment
117 A @dfn{comment} is text that is written in a program only for the sake
118 of humans that read the program, and that has no effect on the meaning
119 of the program. In Lisp, a semicolon (@samp{;}) starts a comment if it
120 is not within a string or character constant. The comment continues to
121 the end of line. The Lisp reader discards comments; they do not become
122 part of the Lisp objects which represent the program within the Lisp
125 The @samp{#@@@var{count}} construct, which skips the next @var{count}
126 characters, is useful for program-generated comments containing binary
127 data. The Emacs Lisp byte compiler uses this in its output files
128 (@pxref{Byte Compilation}). It isn't meant for source files, however.
130 @xref{Comment Tips}, for conventions for formatting comments.
132 @node Programming Types
133 @section Programming Types
134 @cindex programming types
136 There are two general categories of types in Emacs Lisp: those having
137 to do with Lisp programming, and those having to do with editing. The
138 former exist in many Lisp implementations, in one form or another. The
139 latter are unique to Emacs Lisp.
142 * Integer Type:: Numbers without fractional parts.
143 * Floating Point Type:: Numbers with fractional parts and with a large range.
144 * Character Type:: The representation of letters, numbers and
146 * Symbol Type:: A multi-use object that refers to a function,
147 variable, or property list, and has a unique identity.
148 * Sequence Type:: Both lists and arrays are classified as sequences.
149 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
150 * Array Type:: Arrays include strings and vectors.
151 * String Type:: An (efficient) array of characters.
152 * Vector Type:: One-dimensional arrays.
153 * Char-Table Type:: One-dimensional sparse arrays indexed by characters.
154 * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
155 * Hash Table Type:: Super-fast lookup tables.
156 * Function Type:: A piece of executable code you can call from elsewhere.
157 * Macro Type:: A method of expanding an expression into another
158 expression, more fundamental but less pretty.
159 * Primitive Function Type:: A function written in C, callable from Lisp.
160 * Funvec Type:: A vector type callable as a function.
161 * Autoload Type:: A type used for automatically loading seldom-used
166 @subsection Integer Type
168 The range of values for integers in Emacs Lisp is @minus{}536870912 to
169 536870911 (30 bits; i.e.,
183 on most machines. (Some machines may provide a wider range.) It is
184 important to note that the Emacs Lisp arithmetic functions do not check
185 for overflow. Thus @code{(1+ 536870911)} is @minus{}536870912 on most
188 The read syntax for integers is a sequence of (base ten) digits with an
189 optional sign at the beginning and an optional period at the end. The
190 printed representation produced by the Lisp interpreter never has a
191 leading @samp{+} or a final @samp{.}.
195 -1 ; @r{The integer -1.}
196 1 ; @r{The integer 1.}
197 1. ; @r{Also the integer 1.}
198 +1 ; @r{Also the integer 1.}
199 1073741825 ; @r{Also the integer 1 on a 30-bit implementation.}
204 As a special exception, if a sequence of digits specifies an integer
205 too large or too small to be a valid integer object, the Lisp reader
206 reads it as a floating-point number (@pxref{Floating Point Type}).
207 For instance, on most machines @code{536870912} is read as the
208 floating-point number @code{536870912.0}.
210 @xref{Numbers}, for more information.
212 @node Floating Point Type
213 @subsection Floating Point Type
215 Floating point numbers are the computer equivalent of scientific
216 notation; you can think of a floating point number as a fraction
217 together with a power of ten. The precise number of significant
218 figures and the range of possible exponents is machine-specific; Emacs
219 uses the C data type @code{double} to store the value, and internally
220 this records a power of 2 rather than a power of 10.
222 The printed representation for floating point numbers requires either
223 a decimal point (with at least one digit following), an exponent, or
224 both. For example, @samp{1500.0}, @samp{15e2}, @samp{15.0e2},
225 @samp{1.5e3}, and @samp{.15e4} are five ways of writing a floating point
226 number whose value is 1500. They are all equivalent.
228 @xref{Numbers}, for more information.
231 @subsection Character Type
232 @cindex @acronym{ASCII} character codes
234 A @dfn{character} in Emacs Lisp is nothing more than an integer. In
235 other words, characters are represented by their character codes. For
236 example, the character @kbd{A} is represented as the @w{integer 65}.
238 Individual characters are used occasionally in programs, but it is
239 more common to work with @emph{strings}, which are sequences composed
240 of characters. @xref{String Type}.
242 Characters in strings and buffers are currently limited to the range
243 of 0 to 4194303---twenty two bits (@pxref{Character Codes}). Codes 0
244 through 127 are @acronym{ASCII} codes; the rest are
245 non-@acronym{ASCII} (@pxref{Non-ASCII Characters}). Characters that
246 represent keyboard input have a much wider range, to encode modifier
247 keys such as Control, Meta and Shift.
249 There are special functions for producing a human-readable textual
250 description of a character for the sake of messages. @xref{Describing
254 * Basic Char Syntax:: Syntax for regular characters.
255 * General Escape Syntax:: How to specify characters by their codes.
256 * Ctl-Char Syntax:: Syntax for control characters.
257 * Meta-Char Syntax:: Syntax for meta-characters.
258 * Other Char Bits:: Syntax for hyper-, super-, and alt-characters.
261 @node Basic Char Syntax
262 @subsubsection Basic Char Syntax
263 @cindex read syntax for characters
264 @cindex printed representation for characters
265 @cindex syntax for characters
266 @cindex @samp{?} in character constant
267 @cindex question mark in character constant
269 Since characters are really integers, the printed representation of
270 a character is a decimal number. This is also a possible read syntax
271 for a character, but writing characters that way in Lisp programs is
272 not clear programming. You should @emph{always} use the special read
273 syntax formats that Emacs Lisp provides for characters. These syntax
274 formats start with a question mark.
276 The usual read syntax for alphanumeric characters is a question mark
277 followed by the character; thus, @samp{?A} for the character
278 @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
284 ?Q @result{} 81 ?q @result{} 113
287 You can use the same syntax for punctuation characters, but it is
288 often a good idea to add a @samp{\} so that the Emacs commands for
289 editing Lisp code don't get confused. For example, @samp{?\(} is the
290 way to write the open-paren character. If the character is @samp{\},
291 you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.
294 @cindex bell character
298 @cindex tab (ASCII character)
306 @cindex return (ASCII character)
308 @cindex escape (ASCII character)
310 @cindex space (ASCII character)
312 You can express the characters control-g, backspace, tab, newline,
313 vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
314 @samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
315 @samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
316 (@samp{?\s} followed by a dash has a different meaning---it applies
317 the ``super'' modifier to the following character.) Thus,
320 ?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
321 ?\b @result{} 8 ; @r{backspace, @key{BS}, @kbd{C-h}}
322 ?\t @result{} 9 ; @r{tab, @key{TAB}, @kbd{C-i}}
323 ?\n @result{} 10 ; @r{newline, @kbd{C-j}}
324 ?\v @result{} 11 ; @r{vertical tab, @kbd{C-k}}
325 ?\f @result{} 12 ; @r{formfeed character, @kbd{C-l}}
326 ?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
327 ?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
328 ?\s @result{} 32 ; @r{space character, @key{SPC}}
329 ?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
330 ?\d @result{} 127 ; @r{delete character, @key{DEL}}
333 @cindex escape sequence
334 These sequences which start with backslash are also known as
335 @dfn{escape sequences}, because backslash plays the role of an
336 ``escape character''; this terminology has nothing to do with the
337 character @key{ESC}. @samp{\s} is meant for use in character
338 constants; in string constants, just write the space.
340 A backslash is allowed, and harmless, preceding any character without
341 a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
342 There is no reason to add a backslash before most characters. However,
343 you should add a backslash before any of the characters
344 @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
345 Lisp code. You can also add a backslash before whitespace characters such as
346 space, tab, newline and formfeed. However, it is cleaner to use one of
347 the easily readable escape sequences, such as @samp{\t} or @samp{\s},
348 instead of an actual whitespace character such as a tab or a space.
349 (If you do write backslash followed by a space, you should write
350 an extra space after the character constant to separate it from the
353 @node General Escape Syntax
354 @subsubsection General Escape Syntax
356 In addition to the specific escape sequences for special important
357 control characters, Emacs provides several types of escape syntax that
358 you can use to specify non-ASCII text characters.
360 @cindex unicode character escape
361 You can specify characters by their Unicode values.
362 @code{?\u@var{nnnn}} represents a character that maps to the Unicode
363 code point @samp{U+@var{nnnn}} (by convention, Unicode code points are
364 given in hexadecimal). There is a slightly different syntax for
365 specifying characters with code points higher than
366 @code{U+@var{ffff}}: @code{\U00@var{nnnnnn}} represents the character
367 whose code point is @samp{U+@var{nnnnnn}}. The Unicode Standard only
368 defines code points up to @samp{U+@var{10ffff}}, so if you specify a
369 code point higher than that, Emacs signals an error.
371 This peculiar and inconvenient syntax was adopted for compatibility
372 with other programming languages. Unlike some other languages, Emacs
373 Lisp supports this syntax only in character literals and strings.
375 @cindex @samp{\} in character constant
376 @cindex backslash in character constant
377 @cindex octal character code
378 The most general read syntax for a character represents the
379 character code in either octal or hex. To use octal, write a question
380 mark followed by a backslash and the octal character code (up to three
381 octal digits); thus, @samp{?\101} for the character @kbd{A},
382 @samp{?\001} for the character @kbd{C-a}, and @code{?\002} for the
383 character @kbd{C-b}. Although this syntax can represent any
384 @acronym{ASCII} character, it is preferred only when the precise octal
385 value is more important than the @acronym{ASCII} representation.
389 ?\012 @result{} 10 ?\n @result{} 10 ?\C-j @result{} 10
390 ?\101 @result{} 65 ?A @result{} 65
394 To use hex, write a question mark followed by a backslash, @samp{x},
395 and the hexadecimal character code. You can use any number of hex
396 digits, so you can represent any character code in this way.
397 Thus, @samp{?\x41} for the character @kbd{A}, @samp{?\x1} for the
398 character @kbd{C-a}, and @code{?\x8e0} for the Latin-1 character
403 @samp{a} with grave accent.
406 @node Ctl-Char Syntax
407 @subsubsection Control-Character Syntax
409 @cindex control characters
410 Control characters can be represented using yet another read syntax.
411 This consists of a question mark followed by a backslash, caret, and the
412 corresponding non-control character, in either upper or lower case. For
413 example, both @samp{?\^I} and @samp{?\^i} are valid read syntax for the
414 character @kbd{C-i}, the character whose value is 9.
416 Instead of the @samp{^}, you can use @samp{C-}; thus, @samp{?\C-i} is
417 equivalent to @samp{?\^I} and to @samp{?\^i}:
420 ?\^I @result{} 9 ?\C-I @result{} 9
423 In strings and buffers, the only control characters allowed are those
424 that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
425 any character into a control character with @samp{C-}. The character
426 codes for these non-@acronym{ASCII} control characters include the
433 bit as well as the code for the corresponding non-control
434 character. Ordinary terminals have no way of generating non-@acronym{ASCII}
435 control characters, but you can generate them straightforwardly using X
436 and other window systems.
438 For historical reasons, Emacs treats the @key{DEL} character as
439 the control equivalent of @kbd{?}:
442 ?\^? @result{} 127 ?\C-? @result{} 127
446 As a result, it is currently not possible to represent the character
447 @kbd{Control-?}, which is a meaningful input character under X, using
448 @samp{\C-}. It is not easy to change this, as various Lisp files refer
449 to @key{DEL} in this way.
451 For representing control characters to be found in files or strings,
452 we recommend the @samp{^} syntax; for control characters in keyboard
453 input, we prefer the @samp{C-} syntax. Which one you use does not
454 affect the meaning of the program, but may guide the understanding of
457 @node Meta-Char Syntax
458 @subsubsection Meta-Character Syntax
460 @cindex meta characters
461 A @dfn{meta character} is a character typed with the @key{META}
462 modifier key. The integer that represents such a character has the
469 bit set. We use high bits for this and other modifiers to make
470 possible a wide range of basic character codes.
479 bit attached to an @acronym{ASCII} character indicates a meta
480 character; thus, the meta characters that can fit in a string have
481 codes in the range from 128 to 255, and are the meta versions of the
482 ordinary @acronym{ASCII} characters. @xref{Strings of Events}, for
483 details about @key{META}-handling in strings.
485 The read syntax for meta characters uses @samp{\M-}. For example,
486 @samp{?\M-A} stands for @kbd{M-A}. You can use @samp{\M-} together with
487 octal character codes (see below), with @samp{\C-}, or with any other
488 syntax for a character. Thus, you can write @kbd{M-A} as @samp{?\M-A},
489 or as @samp{?\M-\101}. Likewise, you can write @kbd{C-M-b} as
490 @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
492 @node Other Char Bits
493 @subsubsection Other Character Modifier Bits
495 The case of a graphic character is indicated by its character code;
496 for example, @acronym{ASCII} distinguishes between the characters @samp{a}
497 and @samp{A}. But @acronym{ASCII} has no way to represent whether a control
498 character is upper case or lower case. Emacs uses the
505 bit to indicate that the shift key was used in typing a control
506 character. This distinction is possible only when you use X terminals
507 or other special terminals; ordinary terminals do not report the
508 distinction to the computer in any way. The Lisp syntax for
509 the shift bit is @samp{\S-}; thus, @samp{?\C-\S-o} or @samp{?\C-\S-O}
510 represents the shifted-control-o character.
512 @cindex hyper characters
513 @cindex super characters
514 @cindex alt characters
515 The X Window System defines three other
516 @anchor{modifier bits}modifier bits that can be set
517 in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}. The syntaxes
518 for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. (Case is
519 significant in these prefixes.) Thus, @samp{?\H-\M-\A-x} represents
520 @kbd{Alt-Hyper-Meta-x}. (Note that @samp{\s} with no following @samp{-}
521 represents the space character.)
523 Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
524 for super and @math{2^{24}} for hyper.
528 bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
532 @subsection Symbol Type
534 A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The
535 symbol name serves as the printed representation of the symbol. In
536 ordinary Lisp use, with one single obarray (@pxref{Creating Symbols}),
537 a symbol's name is unique---no two symbols have the same name.
539 A symbol can serve as a variable, as a function name, or to hold a
540 property list. Or it may serve only to be distinct from all other Lisp
541 objects, so that its presence in a data structure may be recognized
542 reliably. In a given context, usually only one of these uses is
543 intended. But you can use one symbol in all of these ways,
546 A symbol whose name starts with a colon (@samp{:}) is called a
547 @dfn{keyword symbol}. These symbols automatically act as constants, and
548 are normally used only by comparing an unknown symbol with a few
549 specific alternatives.
551 @cindex @samp{\} in symbols
552 @cindex backslash in symbols
553 A symbol name can contain any characters whatever. Most symbol names
554 are written with letters, digits, and the punctuation characters
555 @samp{-+=*/}. Such names require no special punctuation; the characters
556 of the name suffice as long as the name does not look like a number.
557 (If it does, write a @samp{\} at the beginning of the name to force
558 interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}?} are
559 less often used but also require no special punctuation. Any other
560 characters may be included in a symbol's name by escaping them with a
561 backslash. In contrast to its use in strings, however, a backslash in
562 the name of a symbol simply quotes the single character that follows the
563 backslash. For example, in a string, @samp{\t} represents a tab
564 character; in the name of a symbol, however, @samp{\t} merely quotes the
565 letter @samp{t}. To have a symbol with a tab character in its name, you
566 must actually use a tab (preceded with a backslash). But it's rare to
569 @cindex CL note---case of letters
571 @b{Common Lisp note:} In Common Lisp, lower case letters are always
572 ``folded'' to upper case, unless they are explicitly escaped. In Emacs
573 Lisp, upper case and lower case letters are distinct.
576 Here are several examples of symbol names. Note that the @samp{+} in
577 the fifth example is escaped to prevent it from being read as a number.
578 This is not necessary in the fourth example because the rest of the name
579 makes it invalid as a number.
583 foo ; @r{A symbol named @samp{foo}.}
584 FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
585 char-to-string ; @r{A symbol named @samp{char-to-string}.}
588 1+ ; @r{A symbol named @samp{1+}}
589 ; @r{(not @samp{+1}, which is an integer).}
592 \+1 ; @r{A symbol named @samp{+1}}
593 ; @r{(not a very readable name).}
596 \(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
597 @c the @'s in this next line use up three characters, hence the
598 @c apparent misalignment of the comment.
599 +-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
600 ; @r{These characters need not be escaped.}
605 @c This uses ``colon'' instead of a literal `:' because Info cannot
606 @c cope with a `:' in a menu
607 @cindex @samp{#@var{colon}} read syntax
610 @cindex @samp{#:} read syntax
612 Normally the Lisp reader interns all symbols (@pxref{Creating
613 Symbols}). To prevent interning, you can write @samp{#:} before the
617 @subsection Sequence Types
619 A @dfn{sequence} is a Lisp object that represents an ordered set of
620 elements. There are two kinds of sequence in Emacs Lisp, lists and
621 arrays. Thus, an object of type list or of type array is also
622 considered a sequence.
624 Arrays are further subdivided into strings, vectors, char-tables and
625 bool-vectors. Vectors can hold elements of any type, but string
626 elements must be characters, and bool-vector elements must be @code{t}
627 or @code{nil}. Char-tables are like vectors except that they are
628 indexed by any valid character code. The characters in a string can
629 have text properties like characters in a buffer (@pxref{Text
630 Properties}), but vectors do not support text properties, even when
631 their elements happen to be characters.
633 Lists, strings and the other array types are different, but they have
634 important similarities. For example, all have a length @var{l}, and all
635 have elements which can be indexed from zero to @var{l} minus one.
636 Several functions, called sequence functions, accept any kind of
637 sequence. For example, the function @code{elt} can be used to extract
638 an element of a sequence, given its index. @xref{Sequences Arrays
641 It is generally impossible to read the same sequence twice, since
642 sequences are always created anew upon reading. If you read the read
643 syntax for a sequence twice, you get two sequences with equal contents.
644 There is one exception: the empty list @code{()} always stands for the
645 same object, @code{nil}.
648 @subsection Cons Cell and List Types
649 @cindex address field of register
650 @cindex decrement field of register
653 A @dfn{cons cell} is an object that consists of two slots, called the
654 @sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} or
655 @dfn{refer to} any Lisp object. We also say that ``the @sc{car} of
656 this cons cell is'' whatever object its @sc{car} slot currently holds,
657 and likewise for the @sc{cdr}.
660 A note to C programmers: in Lisp, we do not distinguish between
661 ``holding'' a value and ``pointing to'' the value, because pointers in
665 A @dfn{list} is a series of cons cells, linked together so that the
666 @sc{cdr} slot of each cons cell holds either the next cons cell or the
667 empty list. The empty list is actually the symbol @code{nil}.
668 @xref{Lists}, for functions that work on lists. Because most cons
669 cells are used as part of lists, the phrase @dfn{list structure} has
670 come to refer to any structure made out of cons cells.
673 Because cons cells are so central to Lisp, we also have a word for
674 ``an object which is not a cons cell.'' These objects are called
678 @cindex @samp{(@dots{})} in lists
679 The read syntax and printed representation for lists are identical, and
680 consist of a left parenthesis, an arbitrary number of elements, and a
681 right parenthesis. Here are examples of lists:
684 (A 2 "A") ; @r{A list of three elements.}
685 () ; @r{A list of no elements (the empty list).}
686 nil ; @r{A list of no elements (the empty list).}
687 ("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
688 (A ()) ; @r{A list of two elements: @code{A} and the empty list.}
689 (A nil) ; @r{Equivalent to the previous.}
690 ((A B C)) ; @r{A list of one element}
691 ; @r{(which is a list of three elements).}
694 Upon reading, each object inside the parentheses becomes an element
695 of the list. That is, a cons cell is made for each element. The
696 @sc{car} slot of the cons cell holds the element, and its @sc{cdr}
697 slot refers to the next cons cell of the list, which holds the next
698 element in the list. The @sc{cdr} slot of the last cons cell is set to
701 The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
702 original Lisp implementation ran on an @w{IBM 704} computer which
703 divided words into two parts, called the ``address'' part and the
704 ``decrement''; @sc{car} was an instruction to extract the contents of
705 the address part of a register, and @sc{cdr} an instruction to extract
706 the contents of the decrement. By contrast, ``cons cells'' are named
707 for the function @code{cons} that creates them, which in turn was named
708 for its purpose, the construction of cells.
711 * Box Diagrams:: Drawing pictures of lists.
712 * Dotted Pair Notation:: A general syntax for cons cells.
713 * Association List Type:: A specially constructed list.
717 @subsubsection Drawing Lists as Box Diagrams
718 @cindex box diagrams, for lists
719 @cindex diagrams, boxed, for lists
721 A list can be illustrated by a diagram in which the cons cells are
722 shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
723 such an illustration; unlike the textual notation, which can be
724 understood by both humans and computers, the box illustrations can be
725 understood only by humans.) This picture represents the three-element
726 list @code{(rose violet buttercup)}:
730 --- --- --- --- --- ---
731 | | |--> | | |--> | | |--> nil
732 --- --- --- --- --- ---
735 --> rose --> violet --> buttercup
739 In this diagram, each box represents a slot that can hold or refer to
740 any Lisp object. Each pair of boxes represents a cons cell. Each arrow
741 represents a reference to a Lisp object, either an atom or another cons
744 In this example, the first box, which holds the @sc{car} of the first
745 cons cell, refers to or ``holds'' @code{rose} (a symbol). The second
746 box, holding the @sc{cdr} of the first cons cell, refers to the next
747 pair of boxes, the second cons cell. The @sc{car} of the second cons
748 cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
749 @sc{cdr} of the third (and last) cons cell is @code{nil}.
751 Here is another diagram of the same list, @code{(rose violet
752 buttercup)}, sketched in a different manner:
756 --------------- ---------------- -------------------
757 | car | cdr | | car | cdr | | car | cdr |
758 | rose | o-------->| violet | o-------->| buttercup | nil |
760 --------------- ---------------- -------------------
764 @cindex @code{nil} as a list
766 A list with no elements in it is the @dfn{empty list}; it is identical
767 to the symbol @code{nil}. In other words, @code{nil} is both a symbol
770 Here is the list @code{(A ())}, or equivalently @code{(A nil)},
771 depicted with boxes and arrows:
776 | | |--> | | |--> nil
784 Here is a more complex illustration, showing the three-element list,
785 @code{((pine needles) oak maple)}, the first element of which is a
790 --- --- --- --- --- ---
791 | | |--> | | |--> | | |--> nil
792 --- --- --- --- --- ---
798 --> | | |--> | | |--> nil
806 The same list represented in the second box notation looks like this:
810 -------------- -------------- --------------
811 | car | cdr | | car | cdr | | car | cdr |
812 | o | o------->| oak | o------->| maple | nil |
814 -- | --------- -------------- --------------
817 | -------------- ----------------
818 | | car | cdr | | car | cdr |
819 ------>| pine | o------->| needles | nil |
821 -------------- ----------------
825 @node Dotted Pair Notation
826 @subsubsection Dotted Pair Notation
827 @cindex dotted pair notation
828 @cindex @samp{.} in lists
830 @dfn{Dotted pair notation} is a general syntax for cons cells that
831 represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
832 @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
833 the object @var{a} and whose @sc{cdr} is the object @var{b}. Dotted
834 pair notation is more general than list syntax because the @sc{cdr}
835 does not have to be a list. However, it is more cumbersome in cases
836 where list syntax would work. In dotted pair notation, the list
837 @samp{(1 2 3)} is written as @samp{(1 . (2 . (3 . nil)))}. For
838 @code{nil}-terminated lists, you can use either notation, but list
839 notation is usually clearer and more convenient. When printing a
840 list, the dotted pair notation is only used if the @sc{cdr} of a cons
843 Here's an example using boxes to illustrate dotted pair notation.
844 This example shows the pair @code{(rose . violet)}:
857 You can combine dotted pair notation with list notation to represent
858 conveniently a chain of cons cells with a non-@code{nil} final @sc{cdr}.
859 You write a dot after the last element of the list, followed by the
860 @sc{cdr} of the final cons cell. For example, @code{(rose violet
861 . buttercup)} is equivalent to @code{(rose . (violet . buttercup))}.
862 The object looks like this:
867 | | |--> | | |--> buttercup
875 The syntax @code{(rose .@: violet .@: buttercup)} is invalid because
876 there is nothing that it could mean. If anything, it would say to put
877 @code{buttercup} in the @sc{cdr} of a cons cell whose @sc{cdr} is already
878 used for @code{violet}.
880 The list @code{(rose violet)} is equivalent to @code{(rose . (violet))},
886 | | |--> | | |--> nil
894 Similarly, the three-element list @code{(rose violet buttercup)}
895 is equivalent to @code{(rose . (violet . (buttercup)))}.
901 --- --- --- --- --- ---
902 | | |--> | | |--> | | |--> nil
903 --- --- --- --- --- ---
906 --> rose --> violet --> buttercup
911 @node Association List Type
912 @comment node-name, next, previous, up
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 You can include a non-@acronym{ASCII} international character in a string
1029 constant by writing it literally. There are two text representations
1030 for non-@acronym{ASCII} characters in Emacs strings (and in buffers): unibyte
1031 and multibyte. If the string constant is read from a multibyte source,
1032 such as a multibyte buffer or string, or a file that would be visited as
1033 multibyte, then the character is read as a multibyte character, and that
1034 makes the string multibyte. If the string constant is read from a
1035 unibyte source, then the character is read as unibyte and that makes the
1038 You can also represent a multibyte non-@acronym{ASCII} character with its
1039 character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many
1040 digits as necessary. (Multibyte non-@acronym{ASCII} character codes are all
1041 greater than 256.) Any character which is not a valid hex digit
1042 terminates this construct. If the next character in the string could be
1043 interpreted as a hex digit, write @w{@samp{\ }} (backslash and space) to
1044 terminate the hex escape---for example, @w{@samp{\x8e0\ }} represents
1045 one character, @samp{a} with grave accent. @w{@samp{\ }} in a string
1046 constant is just like backslash-newline; it does not contribute any
1047 character to the string, but it does terminate the preceding hex escape.
1049 You can represent a unibyte non-@acronym{ASCII} character with its
1050 character code, which must be in the range from 128 (0200 octal) to
1051 255 (0377 octal). If you write all such character codes in octal and
1052 the string contains no other characters forcing it to be multibyte,
1053 this produces a unibyte string. However, using any hex escape in a
1054 string (even for an @acronym{ASCII} character) forces the string to be
1057 You can also specify characters in a string by their numeric values
1058 in Unicode, using @samp{\u} and @samp{\U} (@pxref{Character Type}).
1060 @xref{Text Representations}, for more information about the two
1061 text representations.
1063 @node Nonprinting Characters
1064 @subsubsection Nonprinting Characters in Strings
1066 You can use the same backslash escape-sequences in a string constant
1067 as in character literals (but do not use the question mark that begins a
1068 character constant). For example, you can write a string containing the
1069 nonprinting characters tab and @kbd{C-a}, with commas and spaces between
1070 them, like this: @code{"\t, \C-a"}. @xref{Character Type}, for a
1071 description of the read syntax for characters.
1073 However, not all of the characters you can write with backslash
1074 escape-sequences are valid in strings. The only control characters that
1075 a string can hold are the @acronym{ASCII} control characters. Strings do not
1076 distinguish case in @acronym{ASCII} control characters.
1078 Properly speaking, strings cannot hold meta characters; but when a
1079 string is to be used as a key sequence, there is a special convention
1080 that provides a way to represent meta versions of @acronym{ASCII}
1081 characters in a string. If you use the @samp{\M-} syntax to indicate
1082 a meta character in a string constant, this sets the
1089 bit of the character in the string. If the string is used in
1090 @code{define-key} or @code{lookup-key}, this numeric code is translated
1091 into the equivalent meta character. @xref{Character Type}.
1093 Strings cannot hold characters that have the hyper, super, or alt
1096 @node Text Props and Strings
1097 @subsubsection Text Properties in Strings
1099 @cindex @samp{#(} read syntax
1100 @cindex text properties, read syntax
1101 A string can hold properties for the characters it contains, in
1102 addition to the characters themselves. This enables programs that copy
1103 text between strings and buffers to copy the text's properties with no
1104 special effort. @xref{Text Properties}, for an explanation of what text
1105 properties mean. Strings with text properties use a special read and
1109 #("@var{characters}" @var{property-data}...)
1113 where @var{property-data} consists of zero or more elements, in groups
1114 of three as follows:
1117 @var{beg} @var{end} @var{plist}
1121 The elements @var{beg} and @var{end} are integers, and together specify
1122 a range of indices in the string; @var{plist} is the property list for
1123 that range. For example,
1126 #("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))
1130 represents a string whose textual contents are @samp{foo bar}, in which
1131 the first three characters have a @code{face} property with value
1132 @code{bold}, and the last three have a @code{face} property with value
1133 @code{italic}. (The fourth character has no text properties, so its
1134 property list is @code{nil}. It is not actually necessary to mention
1135 ranges with @code{nil} as the property list, since any characters not
1136 mentioned in any range will default to having no properties.)
1139 @subsection Vector Type
1141 A @dfn{vector} is a one-dimensional array of elements of any type. It
1142 takes a constant amount of time to access any element of a vector. (In
1143 a list, the access time of an element is proportional to the distance of
1144 the element from the beginning of the list.)
1146 The printed representation of a vector consists of a left square
1147 bracket, the elements, and a right square bracket. This is also the
1148 read syntax. Like numbers and strings, vectors are considered constants
1152 [1 "two" (three)] ; @r{A vector of three elements.}
1153 @result{} [1 "two" (three)]
1156 @xref{Vectors}, for functions that work with vectors.
1158 @node Char-Table Type
1159 @subsection Char-Table Type
1161 A @dfn{char-table} is a one-dimensional array of elements of any type,
1162 indexed by character codes. Char-tables have certain extra features to
1163 make them more useful for many jobs that involve assigning information
1164 to character codes---for example, a char-table can have a parent to
1165 inherit from, a default value, and a small number of extra slots to use for
1166 special purposes. A char-table can also specify a single value for
1167 a whole character set.
1169 The printed representation of a char-table is like a vector
1170 except that there is an extra @samp{#^} at the beginning.
1172 @xref{Char-Tables}, for special functions to operate on char-tables.
1173 Uses of char-tables include:
1177 Case tables (@pxref{Case Tables}).
1180 Character category tables (@pxref{Categories}).
1183 Display tables (@pxref{Display Tables}).
1186 Syntax tables (@pxref{Syntax Tables}).
1189 @node Bool-Vector Type
1190 @subsection Bool-Vector Type
1192 A @dfn{bool-vector} is a one-dimensional array whose elements must
1193 be @code{t} or @code{nil}.
1195 The printed representation of a bool-vector is like a string, except
1196 that it begins with @samp{#&} followed by the length. The string
1197 constant that follows actually specifies the contents of the bool-vector
1198 as a bitmap---each ``character'' in the string contains 8 bits, which
1199 specify the next 8 elements of the bool-vector (1 stands for @code{t},
1200 and 0 for @code{nil}). The least significant bits of the character
1201 correspond to the lowest indices in the bool-vector.
1204 (make-bool-vector 3 t)
1206 (make-bool-vector 3 nil)
1211 These results make sense, because the binary code for @samp{C-g} is
1212 111 and @samp{C-@@} is the character with code 0.
1214 If the length is not a multiple of 8, the printed representation
1215 shows extra elements, but these extras really make no difference. For
1216 instance, in the next example, the two bool-vectors are equal, because
1217 only the first 3 bits are used:
1220 (equal #&3"\377" #&3"\007")
1224 @node Hash Table Type
1225 @subsection Hash Table Type
1227 A hash table is a very fast kind of lookup table, somewhat like an
1228 alist in that it maps keys to corresponding values, but much faster.
1229 The printed representation of a hash table specifies its properties
1230 and contents, like this:
1234 @result{} #s(hash-table size 65 test eql rehash-size 1.5
1235 rehash-threshold 0.8 data ())
1239 @xref{Hash Tables}, for more information about hash tables.
1242 @subsection Function Type
1244 Lisp functions are executable code, just like functions in other
1245 programming languages. In Lisp, unlike most languages, functions are
1246 also Lisp objects. A non-compiled function in Lisp is a lambda
1247 expression: that is, a list whose first element is the symbol
1248 @code{lambda} (@pxref{Lambda Expressions}).
1250 In most programming languages, it is impossible to have a function
1251 without a name. In Lisp, a function has no intrinsic name. A lambda
1252 expression can be called as a function even though it has no name; to
1253 emphasize this, we also call it an @dfn{anonymous function}
1254 (@pxref{Anonymous Functions}). A named function in Lisp is just a
1255 symbol with a valid function in its function cell (@pxref{Defining
1258 Most of the time, functions are called when their names are written in
1259 Lisp expressions in Lisp programs. However, you can construct or obtain
1260 a function object at run time and then call it with the primitive
1261 functions @code{funcall} and @code{apply}. @xref{Calling Functions}.
1264 @subsection Macro Type
1266 A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
1267 language. It is represented as an object much like a function, but with
1268 different argument-passing semantics. A Lisp macro has the form of a
1269 list whose first element is the symbol @code{macro} and whose @sc{cdr}
1270 is a Lisp function object, including the @code{lambda} symbol.
1272 Lisp macro objects are usually defined with the built-in
1273 @code{defmacro} function, but any list that begins with @code{macro} is
1274 a macro as far as Emacs is concerned. @xref{Macros}, for an explanation
1275 of how to write a macro.
1277 @strong{Warning}: Lisp macros and keyboard macros (@pxref{Keyboard
1278 Macros}) are entirely different things. When we use the word ``macro''
1279 without qualification, we mean a Lisp macro, not a keyboard macro.
1281 @node Primitive Function Type
1282 @subsection Primitive Function Type
1283 @cindex primitive function
1285 A @dfn{primitive function} is a function callable from Lisp but
1286 written in the C programming language. Primitive functions are also
1287 called @dfn{subrs} or @dfn{built-in functions}. (The word ``subr'' is
1288 derived from ``subroutine.'') Most primitive functions evaluate all
1289 their arguments when they are called. A primitive function that does
1290 not evaluate all its arguments is called a @dfn{special form}
1291 (@pxref{Special Forms}).@refill
1293 It does not matter to the caller of a function whether the function is
1294 primitive. However, this does matter if you try to redefine a primitive
1295 with a function written in Lisp. The reason is that the primitive
1296 function may be called directly from C code. Calls to the redefined
1297 function from Lisp will use the new definition, but calls from C code
1298 may still use the built-in definition. Therefore, @strong{we discourage
1299 redefinition of primitive functions}.
1301 The term @dfn{function} refers to all Emacs functions, whether written
1302 in Lisp or C. @xref{Function Type}, for information about the
1303 functions written in Lisp.
1305 Primitive functions have no read syntax and print in hash notation
1306 with the name of the subroutine.
1310 (symbol-function 'car) ; @r{Access the function cell}
1311 ; @r{of the symbol.}
1312 @result{} #<subr car>
1313 (subrp (symbol-function 'car)) ; @r{Is this a primitive function?}
1314 @result{} t ; @r{Yes.}
1319 @subsection ``Function Vector' Type
1320 @cindex function vector
1323 A @dfn{function vector}, or @dfn{funvec} is a vector-like object whose
1324 purpose is to define special kinds of functions. You can examine or
1325 modify the contents of a funvec like a normal vector, using the
1326 @code{aref} and @code{aset} functions.
1328 The behavior of a funvec when called is dependent on the kind of
1329 funvec it is, and that is determined by its first element (a
1330 zero-length funvec will signal an error if called):
1334 A funvec with a list as its first element is a byte-compiled function,
1335 produced by the byte compiler; such funvecs are known as
1336 @dfn{byte-code function objects}. @xref{Byte Compilation}, for
1337 information about the byte compiler.
1339 @item The symbol @code{curry}
1340 A funvec with @code{curry} as its first element is a ``curried function''.
1342 The second element in such a funvec is the function which is
1343 being curried, and the remaining elements are a list of arguments.
1345 Calling such a funvec operates by calling the embedded function with
1346 an argument list composed of the arguments in the funvec followed by
1347 the arguments the funvec was called with. @xref{Function Currying}.
1350 The printed representation and read syntax for a funvec object is like
1351 that for a vector, with an additional @samp{#} before the opening
1354 @defun funvecp object
1355 @code{funvecp} returns @code{t} if @var{object} is a function vector
1356 object (including byte-code objects), and @code{nil} otherwise.
1359 @defun funvec kind &rest params
1360 @code{funvec} returns a new function vector containing @var{kind} and
1361 @var{params}. @var{kind} determines the type of funvec; it should be
1362 one of the choices listed in the table above.
1364 Typically you should use the @code{make-byte-code} function to create
1365 byte-code objects, though they are a type of funvec.
1369 @subsection Autoload Type
1371 An @dfn{autoload object} is a list whose first element is the symbol
1372 @code{autoload}. It is stored as the function definition of a symbol,
1373 where it serves as a placeholder for the real definition. The autoload
1374 object says that the real definition is found in a file of Lisp code
1375 that should be loaded when necessary. It contains the name of the file,
1376 plus some other information about the real definition.
1378 After the file has been loaded, the symbol should have a new function
1379 definition that is not an autoload object. The new definition is then
1380 called as if it had been there to begin with. From the user's point of
1381 view, the function call works as expected, using the function definition
1384 An autoload object is usually created with the function
1385 @code{autoload}, which stores the object in the function cell of a
1386 symbol. @xref{Autoload}, for more details.
1389 @section Editing Types
1390 @cindex editing types
1392 The types in the previous section are used for general programming
1393 purposes, and most of them are common to most Lisp dialects. Emacs Lisp
1394 provides several additional data types for purposes connected with
1398 * Buffer Type:: The basic object of editing.
1399 * Marker Type:: A position in a buffer.
1400 * Window Type:: Buffers are displayed in windows.
1401 * Frame Type:: Windows subdivide frames.
1402 * Terminal Type:: A terminal device displays frames.
1403 * Window Configuration Type:: Recording the way a frame is subdivided.
1404 * Frame Configuration Type:: Recording the status of all frames.
1405 * Process Type:: A subprocess of Emacs running on the underlying OS.
1406 * Stream Type:: Receive or send characters.
1407 * Keymap Type:: What function a keystroke invokes.
1408 * Overlay Type:: How an overlay is represented.
1409 * Font Type:: Fonts for displaying text.
1413 @subsection Buffer Type
1415 A @dfn{buffer} is an object that holds text that can be edited
1416 (@pxref{Buffers}). Most buffers hold the contents of a disk file
1417 (@pxref{Files}) so they can be edited, but some are used for other
1418 purposes. Most buffers are also meant to be seen by the user, and
1419 therefore displayed, at some time, in a window (@pxref{Windows}). But
1420 a buffer need not be displayed in any window. Each buffer has a
1421 designated position called @dfn{point} (@pxref{Positions}); most
1422 editing commands act on the contents of the current buffer in the
1423 neighborhood of point. At any time, one buffer is the @dfn{current
1426 The contents of a buffer are much like a string, but buffers are not
1427 used like strings in Emacs Lisp, and the available operations are
1428 different. For example, you can insert text efficiently into an
1429 existing buffer, altering the buffer's contents, whereas ``inserting''
1430 text into a string requires concatenating substrings, and the result
1431 is an entirely new string object.
1433 Many of the standard Emacs functions manipulate or test the
1434 characters in the current buffer; a whole chapter in this manual is
1435 devoted to describing these functions (@pxref{Text}).
1437 Several other data structures are associated with each buffer:
1441 a local syntax table (@pxref{Syntax Tables});
1444 a local keymap (@pxref{Keymaps}); and,
1447 a list of buffer-local variable bindings (@pxref{Buffer-Local Variables}).
1450 overlays (@pxref{Overlays}).
1453 text properties for the text in the buffer (@pxref{Text Properties}).
1457 The local keymap and variable list contain entries that individually
1458 override global bindings or values. These are used to customize the
1459 behavior of programs in different buffers, without actually changing the
1462 A buffer may be @dfn{indirect}, which means it shares the text
1463 of another buffer, but presents it differently. @xref{Indirect Buffers}.
1465 Buffers have no read syntax. They print in hash notation, showing the
1471 @result{} #<buffer objects.texi>
1476 @subsection Marker Type
1478 A @dfn{marker} denotes a position in a specific buffer. Markers
1479 therefore have two components: one for the buffer, and one for the
1480 position. Changes in the buffer's text automatically relocate the
1481 position value as necessary to ensure that the marker always points
1482 between the same two characters in the buffer.
1484 Markers have no read syntax. They print in hash notation, giving the
1485 current character position and the name of the buffer.
1490 @result{} #<marker at 10779 in objects.texi>
1494 @xref{Markers}, for information on how to test, create, copy, and move
1498 @subsection Window Type
1500 A @dfn{window} describes the portion of the terminal screen that Emacs
1501 uses to display a buffer. Every window has one associated buffer, whose
1502 contents appear in the window. By contrast, a given buffer may appear
1503 in one window, no window, or several windows.
1505 Though many windows may exist simultaneously, at any time one window
1506 is designated the @dfn{selected window}. This is the window where the
1507 cursor is (usually) displayed when Emacs is ready for a command. The
1508 selected window usually displays the current buffer, but this is not
1509 necessarily the case.
1511 Windows are grouped on the screen into frames; each window belongs to
1512 one and only one frame. @xref{Frame Type}.
1514 Windows have no read syntax. They print in hash notation, giving the
1515 window number and the name of the buffer being displayed. The window
1516 numbers exist to identify windows uniquely, since the buffer displayed
1517 in any given window can change frequently.
1522 @result{} #<window 1 on objects.texi>
1526 @xref{Windows}, for a description of the functions that work on windows.
1529 @subsection Frame Type
1531 A @dfn{frame} is a screen area that contains one or more Emacs
1532 windows; we also use the term ``frame'' to refer to the Lisp object
1533 that Emacs uses to refer to the screen area.
1535 Frames have no read syntax. They print in hash notation, giving the
1536 frame's title, plus its address in core (useful to identify the frame
1542 @result{} #<frame emacs@@psilocin.gnu.org 0xdac80>
1546 @xref{Frames}, for a description of the functions that work on frames.
1549 @subsection Terminal Type
1550 @cindex terminal type
1552 A @dfn{terminal} is a device capable of displaying one or more
1553 Emacs frames (@pxref{Frame Type}).
1555 Terminals have no read syntax. They print in hash notation giving
1556 the terminal's ordinal number and its TTY device file name.
1560 (get-device-terminal nil)
1561 @result{} #<terminal 1 on /dev/tty>
1565 @c FIXME: add an xref to where terminal-related primitives are described.
1567 @node Window Configuration Type
1568 @subsection Window Configuration Type
1569 @cindex window layout in a frame
1571 A @dfn{window configuration} stores information about the positions,
1572 sizes, and contents of the windows in a frame, so you can recreate the
1573 same arrangement of windows later.
1575 Window configurations do not have a read syntax; their print syntax
1576 looks like @samp{#<window-configuration>}. @xref{Window
1577 Configurations}, for a description of several functions related to
1578 window configurations.
1580 @node Frame Configuration Type
1581 @subsection Frame Configuration Type
1582 @cindex screen layout
1583 @cindex window layout, all frames
1585 A @dfn{frame configuration} stores information about the positions,
1586 sizes, and contents of the windows in all frames. It is not a
1587 primitive type---it is actually a list whose @sc{car} is
1588 @code{frame-configuration} and whose @sc{cdr} is an alist. Each alist
1589 element describes one frame, which appears as the @sc{car} of that
1592 @xref{Frame Configurations}, for a description of several functions
1593 related to frame configurations.
1596 @subsection Process Type
1598 The word @dfn{process} usually means a running program. Emacs itself
1599 runs in a process of this sort. However, in Emacs Lisp, a process is a
1600 Lisp object that designates a subprocess created by the Emacs process.
1601 Programs such as shells, GDB, ftp, and compilers, running in
1602 subprocesses of Emacs, extend the capabilities of Emacs.
1604 An Emacs subprocess takes textual input from Emacs and returns textual
1605 output to Emacs for further manipulation. Emacs can also send signals
1608 Process objects have no read syntax. They print in hash notation,
1609 giving the name of the process:
1614 @result{} (#<process shell>)
1618 @xref{Processes}, for information about functions that create, delete,
1619 return information about, send input or signals to, and receive output
1623 @subsection Stream Type
1625 A @dfn{stream} is an object that can be used as a source or sink for
1626 characters---either to supply characters for input or to accept them as
1627 output. Many different types can be used this way: markers, buffers,
1628 strings, and functions. Most often, input streams (character sources)
1629 obtain characters from the keyboard, a buffer, or a file, and output
1630 streams (character sinks) send characters to a buffer, such as a
1631 @file{*Help*} buffer, or to the echo area.
1633 The object @code{nil}, in addition to its other meanings, may be used
1634 as a stream. It stands for the value of the variable
1635 @code{standard-input} or @code{standard-output}. Also, the object
1636 @code{t} as a stream specifies input using the minibuffer
1637 (@pxref{Minibuffers}) or output in the echo area (@pxref{The Echo
1640 Streams have no special printed representation or read syntax, and
1641 print as whatever primitive type they are.
1643 @xref{Read and Print}, for a description of functions
1644 related to streams, including parsing and printing functions.
1647 @subsection Keymap Type
1649 A @dfn{keymap} maps keys typed by the user to commands. This mapping
1650 controls how the user's command input is executed. A keymap is actually
1651 a list whose @sc{car} is the symbol @code{keymap}.
1653 @xref{Keymaps}, for information about creating keymaps, handling prefix
1654 keys, local as well as global keymaps, and changing key bindings.
1657 @subsection Overlay Type
1659 An @dfn{overlay} specifies properties that apply to a part of a
1660 buffer. Each overlay applies to a specified range of the buffer, and
1661 contains a property list (a list whose elements are alternating property
1662 names and values). Overlay properties are used to present parts of the
1663 buffer temporarily in a different display style. Overlays have no read
1664 syntax, and print in hash notation, giving the buffer name and range of
1667 @xref{Overlays}, for how to create and use overlays.
1670 @subsection Font Type
1672 A @dfn{font} specifies how to display text on a graphical terminal.
1673 There are actually three separate font types---@dfn{font objects},
1674 @dfn{font specs}, and @dfn{font entities}---each of which has slightly
1675 different properties. None of them have a read syntax; their print
1676 syntax looks like @samp{#<font-object>}, @samp{#<font-spec>}, and
1677 @samp{#<font-entity>} respectively. @xref{Low-Level Font}, for a
1678 description of these Lisp objects.
1680 @node Circular Objects
1681 @section Read Syntax for Circular Objects
1682 @cindex circular structure, read syntax
1683 @cindex shared structure, read syntax
1684 @cindex @samp{#@var{n}=} read syntax
1685 @cindex @samp{#@var{n}#} read syntax
1687 To represent shared or circular structures within a complex of Lisp
1688 objects, you can use the reader constructs @samp{#@var{n}=} and
1691 Use @code{#@var{n}=} before an object to label it for later reference;
1692 subsequently, you can use @code{#@var{n}#} to refer the same object in
1693 another place. Here, @var{n} is some integer. For example, here is how
1694 to make a list in which the first element recurs as the third element:
1701 This differs from ordinary syntax such as this
1708 which would result in a list whose first and third elements
1709 look alike but are not the same Lisp object. This shows the difference:
1713 (setq x '(#1=(a) b #1#)))
1714 (eq (nth 0 x) (nth 2 x))
1716 (setq x '((a) b (a)))
1717 (eq (nth 0 x) (nth 2 x))
1721 You can also use the same syntax to make a circular structure, which
1722 appears as an ``element'' within itself. Here is an example:
1729 This makes a list whose second element is the list itself.
1730 Here's how you can see that it really works:
1734 (setq x '#1=(a #1#)))
1739 The Lisp printer can produce this syntax to record circular and shared
1740 structure in a Lisp object, if you bind the variable @code{print-circle}
1741 to a non-@code{nil} value. @xref{Output Variables}.
1743 @node Type Predicates
1744 @section Type Predicates
1745 @cindex type checking
1746 @kindex wrong-type-argument
1748 The Emacs Lisp interpreter itself does not perform type checking on
1749 the actual arguments passed to functions when they are called. It could
1750 not do so, since function arguments in Lisp do not have declared data
1751 types, as they do in other programming languages. It is therefore up to
1752 the individual function to test whether each actual argument belongs to
1753 a type that the function can use.
1755 All built-in functions do check the types of their actual arguments
1756 when appropriate, and signal a @code{wrong-type-argument} error if an
1757 argument is of the wrong type. For example, here is what happens if you
1758 pass an argument to @code{+} that it cannot handle:
1763 @error{} Wrong type argument: number-or-marker-p, a
1767 @cindex type predicates
1768 @cindex testing types
1769 If you want your program to handle different types differently, you
1770 must do explicit type checking. The most common way to check the type
1771 of an object is to call a @dfn{type predicate} function. Emacs has a
1772 type predicate for each type, as well as some predicates for
1773 combinations of types.
1775 A type predicate function takes one argument; it returns @code{t} if
1776 the argument belongs to the appropriate type, and @code{nil} otherwise.
1777 Following a general Lisp convention for predicate functions, most type
1778 predicates' names end with @samp{p}.
1780 Here is an example which uses the predicates @code{listp} to check for
1781 a list and @code{symbolp} to check for a symbol.
1786 ;; If X is a symbol, put it on LIST.
1787 (setq list (cons x list)))
1789 ;; If X is a list, add its elements to LIST.
1790 (setq list (append x list)))
1792 ;; We handle only symbols and lists.
1793 (error "Invalid argument %s in add-on" x))))
1796 Here is a table of predefined type predicates, in alphabetical order,
1797 with references to further information.
1801 @xref{List-related Predicates, atom}.
1804 @xref{Array Functions, arrayp}.
1807 @xref{Bool-Vectors, bool-vector-p}.
1810 @xref{Buffer Basics, bufferp}.
1812 @item byte-code-function-p
1813 @xref{Funvec Type, byte-code-function-p}.
1816 @xref{Case Tables, case-table-p}.
1818 @item char-or-string-p
1819 @xref{Predicates for Strings, char-or-string-p}.
1822 @xref{Char-Tables, char-table-p}.
1825 @xref{Interactive Call, commandp}.
1828 @xref{List-related Predicates, consp}.
1830 @item display-table-p
1831 @xref{Display Tables, display-table-p}.
1834 @xref{Predicates on Numbers, floatp}.
1837 @xref{Low-Level Font}.
1839 @item frame-configuration-p
1840 @xref{Frame Configurations, frame-configuration-p}.
1843 @xref{Deleting Frames, frame-live-p}.
1846 @xref{Frames, framep}.
1849 @xref{Functions, functionp}.
1852 @xref{Other Hash, hash-table-p}.
1854 @item integer-or-marker-p
1855 @xref{Predicates on Markers, integer-or-marker-p}.
1858 @xref{Predicates on Numbers, integerp}.
1861 @xref{Creating Keymaps, keymapp}.
1864 @xref{Constant Variables}.
1867 @xref{List-related Predicates, listp}.
1870 @xref{Predicates on Markers, markerp}.
1873 @xref{Predicates on Numbers, wholenump}.
1876 @xref{List-related Predicates, nlistp}.
1879 @xref{Predicates on Numbers, numberp}.
1881 @item number-or-marker-p
1882 @xref{Predicates on Markers, number-or-marker-p}.
1885 @xref{Overlays, overlayp}.
1888 @xref{Processes, processp}.
1891 @xref{Sequence Functions, sequencep}.
1894 @xref{Predicates for Strings, stringp}.
1897 @xref{Function Cells, subrp}.
1900 @xref{Symbols, symbolp}.
1902 @item syntax-table-p
1903 @xref{Syntax Tables, syntax-table-p}.
1905 @item user-variable-p
1906 @xref{Defining Variables, user-variable-p}.
1909 @xref{Vectors, vectorp}.
1911 @item window-configuration-p
1912 @xref{Window Configurations, window-configuration-p}.
1915 @xref{Deleting Windows, window-live-p}.
1918 @xref{Basic Windows, windowp}.
1921 @xref{nil and t, booleanp}.
1923 @item string-or-null-p
1924 @xref{Predicates for Strings, string-or-null-p}.
1927 The most general way to check the type of an object is to call the
1928 function @code{type-of}. Recall that each object belongs to one and
1929 only one primitive type; @code{type-of} tells you which one (@pxref{Lisp
1930 Data Types}). But @code{type-of} knows nothing about non-primitive
1931 types. In most cases, it is more convenient to use type predicates than
1934 @defun type-of object
1935 This function returns a symbol naming the primitive type of
1936 @var{object}. The value is one of the symbols @code{bool-vector},
1937 @code{buffer}, @code{char-table}, @code{compiled-function},
1938 @code{cons}, @code{float}, @code{font-entity}, @code{font-object},
1939 @code{font-spec}, @code{frame}, @code{hash-table}, @code{integer},
1940 @code{marker}, @code{overlay}, @code{process}, @code{string},
1941 @code{subr}, @code{symbol}, @code{vector}, @code{window}, or
1942 @code{window-configuration}.
1950 (type-of '()) ; @r{@code{()} is @code{nil}.}
1958 @node Equality Predicates
1959 @section Equality Predicates
1962 Here we describe functions that test for equality between any two
1963 objects. Other functions test equality of contents between objects of specific
1964 types, e.g., strings. For these predicates, see the appropriate chapter
1965 describing the data type.
1967 @defun eq object1 object2
1968 This function returns @code{t} if @var{object1} and @var{object2} are
1969 the same object, @code{nil} otherwise.
1971 @code{eq} returns @code{t} if @var{object1} and @var{object2} are
1972 integers with the same value. Also, since symbol names are normally
1973 unique, if the arguments are symbols with the same name, they are
1974 @code{eq}. For other types (e.g., lists, vectors, strings), two
1975 arguments with the same contents or elements are not necessarily
1976 @code{eq} to each other: they are @code{eq} only if they are the same
1977 object, meaning that a change in the contents of one will be reflected
1978 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))
2028 The @code{make-symbol} function returns an uninterned symbol, distinct
2029 from the symbol that is used if you write the name in a Lisp expression.
2030 Distinct symbols with the same name are not @code{eq}. @xref{Creating
2035 (eq (make-symbol "foo") 'foo)
2041 @defun equal object1 object2
2042 This function returns @code{t} if @var{object1} and @var{object2} have
2043 equal components, @code{nil} otherwise. Whereas @code{eq} tests if its
2044 arguments are the same object, @code{equal} looks inside nonidentical
2045 arguments to see if their elements or contents are the same. So, if two
2046 objects are @code{eq}, they are @code{equal}, but the converse is not
2061 (equal "asdf" "asdf")
2070 (equal '(1 (2 (3))) '(1 (2 (3))))
2074 (eq '(1 (2 (3))) '(1 (2 (3))))
2079 (equal [(1 2) 3] [(1 2) 3])
2083 (eq [(1 2) 3] [(1 2) 3])
2088 (equal (point-marker) (point-marker))
2093 (eq (point-marker) (point-marker))
2098 Comparison of strings is case-sensitive, but does not take account of
2099 text properties---it compares only the characters in the strings. Use
2100 @code{equal-including-properties} to also compare text properties. For
2101 technical reasons, a unibyte string and a multibyte string are
2102 @code{equal} if and only if they contain the same sequence of
2103 character codes and all these codes are either in the range 0 through
2104 127 (@acronym{ASCII}) or 160 through 255 (@code{eight-bit-graphic}).
2105 (@pxref{Text Representations}).
2109 (equal "asdf" "ASDF")
2114 However, two distinct buffers are never considered @code{equal}, even if
2115 their textual contents are the same.
2118 The test for equality is implemented recursively; for example, given
2119 two cons cells @var{x} and @var{y}, @code{(equal @var{x} @var{y})}
2120 returns @code{t} if and only if both the expressions below return
2124 (equal (car @var{x}) (car @var{y}))
2125 (equal (cdr @var{x}) (cdr @var{y}))
2128 Because of this recursive method, circular lists may therefore cause
2129 infinite recursion (leading to an error).
2131 @defun equal-including-properties object1 object2
2132 This function behaves like @code{equal} in all cases but also requires
2133 that for two strings to be equal, they have the same text properties.
2137 (equal "asdf" (propertize "asdf" '(asdf t)))
2141 (equal-including-properties "asdf"
2142 (propertize "asdf" '(asdf t)))
2149 arch-tag: 9711a66e-4749-4265-9e8c-972d55b67096