2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002, 2003,
4 @c 2004, 2005, 2006 Free Software Foundation, Inc.
5 @c See the file elisp.texi for copying conditions.
6 @setfilename ../info/objects
7 @node Lisp Data Types, Numbers, Introduction, Top
8 @chapter Lisp Data Types
14 A Lisp @dfn{object} is a piece of data used and manipulated by Lisp
15 programs. For our purposes, a @dfn{type} or @dfn{data type} is a set of
18 Every object belongs to at least one type. Objects of the same type
19 have similar structures and may usually be used in the same contexts.
20 Types can overlap, and objects can belong to two or more types.
21 Consequently, we can ask whether an object belongs to a particular type,
22 but not for ``the'' type of an object.
24 @cindex primitive type
25 A few fundamental object types are built into Emacs. These, from
26 which all other types are constructed, are called @dfn{primitive types}.
27 Each object belongs to one and only one primitive type. These types
28 include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
29 @dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
30 @dfn{byte-code function}, plus several special types, such as
31 @dfn{buffer}, that are related to editing. (@xref{Editing Types}.)
33 Each primitive type has a corresponding Lisp function that checks
34 whether an object is a member of that type.
36 Note that Lisp is unlike many other languages in that Lisp objects are
37 @dfn{self-typing}: the primitive type of the object is implicit in the
38 object itself. For example, if an object is a vector, nothing can treat
39 it as a number; Lisp knows it is a vector, not a number.
41 In most languages, the programmer must declare the data type of each
42 variable, and the type is known by the compiler but not represented in
43 the data. Such type declarations do not exist in Emacs Lisp. A Lisp
44 variable can have any type of value, and it remembers whatever value
45 you store in it, type and all. (Actually, a small number of Emacs
46 Lisp variables can only take on values of a certain type.
47 @xref{Variables with Restricted Values}.)
49 This chapter describes the purpose, printed representation, and read
50 syntax of each of the standard types in GNU Emacs Lisp. Details on how
51 to use these types can be found in later chapters.
54 * Printed Representation:: How Lisp objects are represented as text.
55 * Comments:: Comments and their formatting conventions.
56 * Programming Types:: Types found in all Lisp systems.
57 * Editing Types:: Types specific to Emacs.
58 * Circular Objects:: Read syntax for circular structure.
59 * Type Predicates:: Tests related to types.
60 * Equality Predicates:: Tests of equality between any two objects.
63 @node Printed Representation
64 @comment node-name, next, previous, up
65 @section Printed Representation and Read Syntax
66 @cindex printed representation
69 The @dfn{printed representation} of an object is the format of the
70 output generated by the Lisp printer (the function @code{prin1}) for
71 that object. Every data type has a unique printed representation.
72 The @dfn{read syntax} of an object is the format of the input accepted
73 by the Lisp reader (the function @code{read}) for that object. This
74 is not necessarily unique; many kinds of object have more than one
75 syntax. @xref{Read and Print}.
78 In most cases, an object's printed representation is also a read
79 syntax for the object. However, some types have no read syntax, since
80 it does not make sense to enter objects of these types as constants in
81 a Lisp program. These objects are printed in @dfn{hash notation},
82 which consists of the characters @samp{#<}, a descriptive string
83 (typically the type name followed by the name of the object), and a
84 closing @samp{>}. For example:
88 @result{} #<buffer objects.texi>
92 Hash notation cannot be read at all, so the Lisp reader signals the
93 error @code{invalid-read-syntax} whenever it encounters @samp{#<}.
94 @kindex invalid-read-syntax
96 In other languages, an expression is text; it has no other form. In
97 Lisp, an expression is primarily a Lisp object and only secondarily the
98 text that is the object's read syntax. Often there is no need to
99 emphasize this distinction, but you must keep it in the back of your
100 mind, or you will occasionally be very confused.
102 When you evaluate an expression interactively, the Lisp interpreter
103 first reads the textual representation of it, producing a Lisp object,
104 and then evaluates that object (@pxref{Evaluation}). However,
105 evaluation and reading are separate activities. Reading returns the
106 Lisp object represented by the text that is read; the object may or may
107 not be evaluated later. @xref{Input Functions}, for a description of
108 @code{read}, the basic function for reading objects.
111 @comment node-name, next, previous, up
114 @cindex @samp{;} in comment
116 A @dfn{comment} is text that is written in a program only for the sake
117 of humans that read the program, and that has no effect on the meaning
118 of the program. In Lisp, a semicolon (@samp{;}) starts a comment if it
119 is not within a string or character constant. The comment continues to
120 the end of line. The Lisp reader discards comments; they do not become
121 part of the Lisp objects which represent the program within the Lisp
124 The @samp{#@@@var{count}} construct, which skips the next @var{count}
125 characters, is useful for program-generated comments containing binary
126 data. The Emacs Lisp byte compiler uses this in its output files
127 (@pxref{Byte Compilation}). It isn't meant for source files, however.
129 @xref{Comment Tips}, for conventions for formatting comments.
131 @node Programming Types
132 @section Programming Types
133 @cindex programming types
135 There are two general categories of types in Emacs Lisp: those having
136 to do with Lisp programming, and those having to do with editing. The
137 former exist in many Lisp implementations, in one form or another. The
138 latter are unique to Emacs Lisp.
141 * Integer Type:: Numbers without fractional parts.
142 * Floating Point Type:: Numbers with fractional parts and with a large range.
143 * Character Type:: The representation of letters, numbers and
145 * Symbol Type:: A multi-use object that refers to a function,
146 variable, or property list, and has a unique identity.
147 * Sequence Type:: Both lists and arrays are classified as sequences.
148 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
149 * Array Type:: Arrays include strings and vectors.
150 * String Type:: An (efficient) array of characters.
151 * Vector Type:: One-dimensional arrays.
152 * Char-Table Type:: One-dimensional sparse arrays indexed by characters.
153 * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
154 * Hash Table Type:: Super-fast lookup tables.
155 * Function Type:: A piece of executable code you can call from elsewhere.
156 * Macro Type:: A method of expanding an expression into another
157 expression, more fundamental but less pretty.
158 * Primitive Function Type:: A function written in C, callable from Lisp.
159 * Byte-Code Type:: A function written in Lisp, then compiled.
160 * Autoload Type:: A type used for automatically loading seldom-used
165 @subsection Integer Type
167 The range of values for integers in Emacs Lisp is @minus{}268435456 to
168 268435455 (29 bits; i.e.,
182 on most machines. (Some machines may provide a wider range.) It is
183 important to note that the Emacs Lisp arithmetic functions do not check
184 for overflow. Thus @code{(1+ 268435455)} is @minus{}268435456 on most
187 The read syntax for integers is a sequence of (base ten) digits with an
188 optional sign at the beginning and an optional period at the end. The
189 printed representation produced by the Lisp interpreter never has a
190 leading @samp{+} or a final @samp{.}.
194 -1 ; @r{The integer -1.}
195 1 ; @r{The integer 1.}
196 1. ; @r{Also the integer 1.}
197 +1 ; @r{Also the integer 1.}
198 536870913 ; @r{Also the integer 1 on a 29-bit implementation.}
202 @xref{Numbers}, for more information.
204 @node Floating Point Type
205 @subsection Floating Point Type
207 Floating point numbers are the computer equivalent of scientific
208 notation; you can think of a floating point number as a fraction
209 together with a power of ten. The precise number of significant
210 figures and the range of possible exponents is machine-specific; Emacs
211 uses the C data type @code{double} to store the value, and internally
212 this records a power of 2 rather than a power of 10.
214 The printed representation for floating point numbers requires either
215 a decimal point (with at least one digit following), an exponent, or
216 both. For example, @samp{1500.0}, @samp{15e2}, @samp{15.0e2},
217 @samp{1.5e3}, and @samp{.15e4} are five ways of writing a floating point
218 number whose value is 1500. They are all equivalent.
220 @xref{Numbers}, for more information.
223 @subsection Character Type
224 @cindex @acronym{ASCII} character codes
226 A @dfn{character} in Emacs Lisp is nothing more than an integer. In
227 other words, characters are represented by their character codes. For
228 example, the character @kbd{A} is represented as the @w{integer 65}.
230 Individual characters are not often used in programs. It is far more
231 common to work with @emph{strings}, which are sequences composed of
232 characters. @xref{String Type}.
234 Characters in strings, buffers, and files are currently limited to
235 the range of 0 to 524287---nineteen bits. But not all values in that
236 range are valid character codes. Codes 0 through 127 are
237 @acronym{ASCII} codes; the rest are non-@acronym{ASCII}
238 (@pxref{Non-ASCII Characters}). Characters that represent keyboard
239 input have a much wider range, to encode modifier keys such as
240 Control, Meta and Shift.
242 @cindex read syntax for characters
243 @cindex printed representation for characters
244 @cindex syntax for characters
245 @cindex @samp{?} in character constant
246 @cindex question mark in character constant
247 Since characters are really integers, the printed representation of a
248 character is a decimal number. This is also a possible read syntax for
249 a character, but writing characters that way in Lisp programs is a very
250 bad idea. You should @emph{always} use the special read syntax formats
251 that Emacs Lisp provides for characters. These syntax formats start
252 with a question mark.
254 The usual read syntax for alphanumeric characters is a question mark
255 followed by the character; thus, @samp{?A} for the character
256 @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
262 ?Q @result{} 81 ?q @result{} 113
265 You can use the same syntax for punctuation characters, but it is
266 often a good idea to add a @samp{\} so that the Emacs commands for
267 editing Lisp code don't get confused. For example, @samp{?\(} is the
268 way to write the open-paren character. If the character is @samp{\},
269 you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.
272 @cindex bell character
290 You can express the characters control-g, backspace, tab, newline,
291 vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
292 @samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
293 @samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
294 (@samp{?\s} followed by a dash has a different meaning---it applies
295 the ``super'' modifier to the following character.) Thus,
298 ?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
299 ?\b @result{} 8 ; @r{backspace, @key{BS}, @kbd{C-h}}
300 ?\t @result{} 9 ; @r{tab, @key{TAB}, @kbd{C-i}}
301 ?\n @result{} 10 ; @r{newline, @kbd{C-j}}
302 ?\v @result{} 11 ; @r{vertical tab, @kbd{C-k}}
303 ?\f @result{} 12 ; @r{formfeed character, @kbd{C-l}}
304 ?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
305 ?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
306 ?\s @result{} 32 ; @r{space character, @key{SPC}}
307 ?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
308 ?\d @result{} 127 ; @r{delete character, @key{DEL}}
311 @cindex escape sequence
312 These sequences which start with backslash are also known as
313 @dfn{escape sequences}, because backslash plays the role of an
314 ``escape character''; this terminology has nothing to do with the
315 character @key{ESC}. @samp{\s} is meant for use in character
316 constants; in string constants, just write the space.
318 @cindex control characters
319 Control characters may be represented using yet another read syntax.
320 This consists of a question mark followed by a backslash, caret, and the
321 corresponding non-control character, in either upper or lower case. For
322 example, both @samp{?\^I} and @samp{?\^i} are valid read syntax for the
323 character @kbd{C-i}, the character whose value is 9.
325 Instead of the @samp{^}, you can use @samp{C-}; thus, @samp{?\C-i} is
326 equivalent to @samp{?\^I} and to @samp{?\^i}:
329 ?\^I @result{} 9 ?\C-I @result{} 9
332 In strings and buffers, the only control characters allowed are those
333 that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
334 any character into a control character with @samp{C-}. The character
335 codes for these non-@acronym{ASCII} control characters include the
342 bit as well as the code for the corresponding non-control
343 character. Ordinary terminals have no way of generating non-@acronym{ASCII}
344 control characters, but you can generate them straightforwardly using X
345 and other window systems.
347 For historical reasons, Emacs treats the @key{DEL} character as
348 the control equivalent of @kbd{?}:
351 ?\^? @result{} 127 ?\C-? @result{} 127
355 As a result, it is currently not possible to represent the character
356 @kbd{Control-?}, which is a meaningful input character under X, using
357 @samp{\C-}. It is not easy to change this, as various Lisp files refer
358 to @key{DEL} in this way.
360 For representing control characters to be found in files or strings,
361 we recommend the @samp{^} syntax; for control characters in keyboard
362 input, we prefer the @samp{C-} syntax. Which one you use does not
363 affect the meaning of the program, but may guide the understanding of
366 @cindex meta characters
367 A @dfn{meta character} is a character typed with the @key{META}
368 modifier key. The integer that represents such a character has the
375 bit set. We use high bits for this and other modifiers to make
376 possible a wide range of basic character codes.
385 bit attached to an @acronym{ASCII} character indicates a meta
386 character; thus, the meta characters that can fit in a string have
387 codes in the range from 128 to 255, and are the meta versions of the
388 ordinary @acronym{ASCII} characters. (In Emacs versions 18 and older,
389 this convention was used for characters outside of strings as well.)
391 The read syntax for meta characters uses @samp{\M-}. For example,
392 @samp{?\M-A} stands for @kbd{M-A}. You can use @samp{\M-} together with
393 octal character codes (see below), with @samp{\C-}, or with any other
394 syntax for a character. Thus, you can write @kbd{M-A} as @samp{?\M-A},
395 or as @samp{?\M-\101}. Likewise, you can write @kbd{C-M-b} as
396 @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
398 The case of a graphic character is indicated by its character code;
399 for example, @acronym{ASCII} distinguishes between the characters @samp{a}
400 and @samp{A}. But @acronym{ASCII} has no way to represent whether a control
401 character is upper case or lower case. Emacs uses the
408 bit to indicate that the shift key was used in typing a control
409 character. This distinction is possible only when you use X terminals
410 or other special terminals; ordinary terminals do not report the
411 distinction to the computer in any way. The Lisp syntax for
412 the shift bit is @samp{\S-}; thus, @samp{?\C-\S-o} or @samp{?\C-\S-O}
413 represents the shifted-control-o character.
415 @cindex hyper characters
416 @cindex super characters
417 @cindex alt characters
418 The X Window System defines three other
419 @anchor{modifier bits}modifier bits that can be set
420 in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}. The syntaxes
421 for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. (Case is
422 significant in these prefixes.) Thus, @samp{?\H-\M-\A-x} represents
423 @kbd{Alt-Hyper-Meta-x}. (Note that @samp{\s} with no following @samp{-}
424 represents the space character.)
426 Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
427 for super and @math{2^{24}} for hyper.
431 bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
434 @cindex unicode character escape
435 Emacs provides a syntax for specifying characters by their Unicode
436 code points. @code{?\u@var{nnnn}} represents a character that maps to
437 the Unicode code point @samp{U+@var{nnnn}}. There is a slightly
438 different syntax for specifying characters with code points above
439 @code{#xFFFF}; @code{\U00@var{nnnnnn}} represents the character whose
440 Unicode code point is @samp{U+@var{nnnnnn}}, if such a character
441 is supported by Emacs.
443 This peculiar and inconvenient syntax was adopted for compatibility
444 with other programming languages. Unlike some other languages, Emacs
445 Lisp supports this syntax in only character literals and strings.
447 @cindex @samp{\} in character constant
448 @cindex backslash in character constant
449 @cindex octal character code
450 Finally, the most general read syntax for a character represents the
451 character code in either octal or hex. To use octal, write a question
452 mark followed by a backslash and the octal character code (up to three
453 octal digits); thus, @samp{?\101} for the character @kbd{A},
454 @samp{?\001} for the character @kbd{C-a}, and @code{?\002} for the
455 character @kbd{C-b}. Although this syntax can represent any @acronym{ASCII}
456 character, it is preferred only when the precise octal value is more
457 important than the @acronym{ASCII} representation.
461 ?\012 @result{} 10 ?\n @result{} 10 ?\C-j @result{} 10
462 ?\101 @result{} 65 ?A @result{} 65
466 To use hex, write a question mark followed by a backslash, @samp{x},
467 and the hexadecimal character code. You can use any number of hex
468 digits, so you can represent any character code in this way.
469 Thus, @samp{?\x41} for the character @kbd{A}, @samp{?\x1} for the
470 character @kbd{C-a}, and @code{?\x8e0} for the Latin-1 character
475 @samp{a} with grave accent.
478 A backslash is allowed, and harmless, preceding any character without
479 a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
480 There is no reason to add a backslash before most characters. However,
481 you should add a backslash before any of the characters
482 @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
483 Lisp code. You can also add a backslash before whitespace characters such as
484 space, tab, newline and formfeed. However, it is cleaner to use one of
485 the easily readable escape sequences, such as @samp{\t} or @samp{\s},
486 instead of an actual whitespace character such as a tab or a space.
487 (If you do write backslash followed by a space, you should write
488 an extra space after the character constant to separate it from the
492 @subsection Symbol Type
494 A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The
495 symbol name serves as the printed representation of the symbol. In
496 ordinary Lisp use, with one single obarray (@pxref{Creating Symbols},
497 a symbol's name is unique---no two symbols have the same name.
499 A symbol can serve as a variable, as a function name, or to hold a
500 property list. Or it may serve only to be distinct from all other Lisp
501 objects, so that its presence in a data structure may be recognized
502 reliably. In a given context, usually only one of these uses is
503 intended. But you can use one symbol in all of these ways,
506 A symbol whose name starts with a colon (@samp{:}) is called a
507 @dfn{keyword symbol}. These symbols automatically act as constants, and
508 are normally used only by comparing an unknown symbol with a few
509 specific alternatives.
511 @cindex @samp{\} in symbols
512 @cindex backslash in symbols
513 A symbol name can contain any characters whatever. Most symbol names
514 are written with letters, digits, and the punctuation characters
515 @samp{-+=*/}. Such names require no special punctuation; the characters
516 of the name suffice as long as the name does not look like a number.
517 (If it does, write a @samp{\} at the beginning of the name to force
518 interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}?} are
519 less often used but also require no special punctuation. Any other
520 characters may be included in a symbol's name by escaping them with a
521 backslash. In contrast to its use in strings, however, a backslash in
522 the name of a symbol simply quotes the single character that follows the
523 backslash. For example, in a string, @samp{\t} represents a tab
524 character; in the name of a symbol, however, @samp{\t} merely quotes the
525 letter @samp{t}. To have a symbol with a tab character in its name, you
526 must actually use a tab (preceded with a backslash). But it's rare to
529 @cindex CL note---case of letters
531 @b{Common Lisp note:} In Common Lisp, lower case letters are always
532 ``folded'' to upper case, unless they are explicitly escaped. In Emacs
533 Lisp, upper case and lower case letters are distinct.
536 Here are several examples of symbol names. Note that the @samp{+} in
537 the fifth example is escaped to prevent it from being read as a number.
538 This is not necessary in the fourth example because the rest of the name
539 makes it invalid as a number.
543 foo ; @r{A symbol named @samp{foo}.}
544 FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
545 char-to-string ; @r{A symbol named @samp{char-to-string}.}
548 1+ ; @r{A symbol named @samp{1+}}
549 ; @r{(not @samp{+1}, which is an integer).}
552 \+1 ; @r{A symbol named @samp{+1}}
553 ; @r{(not a very readable name).}
556 \(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
557 @c the @'s in this next line use up three characters, hence the
558 @c apparent misalignment of the comment.
559 +-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
560 ; @r{These characters need not be escaped.}
565 @c This uses ``colon'' instead of a literal `:' because Info cannot
566 @c cope with a `:' in a menu
567 @cindex @samp{#@var{colon}} read syntax
570 @cindex @samp{#:} read syntax
572 Normally the Lisp reader interns all symbols (@pxref{Creating
573 Symbols}). To prevent interning, you can write @samp{#:} before the
577 @subsection Sequence Types
579 A @dfn{sequence} is a Lisp object that represents an ordered set of
580 elements. There are two kinds of sequence in Emacs Lisp, lists and
581 arrays. Thus, an object of type list or of type array is also
582 considered a sequence.
584 Arrays are further subdivided into strings, vectors, char-tables and
585 bool-vectors. Vectors can hold elements of any type, but string
586 elements must be characters, and bool-vector elements must be @code{t}
587 or @code{nil}. Char-tables are like vectors except that they are
588 indexed by any valid character code. The characters in a string can
589 have text properties like characters in a buffer (@pxref{Text
590 Properties}), but vectors do not support text properties, even when
591 their elements happen to be characters.
593 Lists, strings and the other array types are different, but they have
594 important similarities. For example, all have a length @var{l}, and all
595 have elements which can be indexed from zero to @var{l} minus one.
596 Several functions, called sequence functions, accept any kind of
597 sequence. For example, the function @code{elt} can be used to extract
598 an element of a sequence, given its index. @xref{Sequences Arrays
601 It is generally impossible to read the same sequence twice, since
602 sequences are always created anew upon reading. If you read the read
603 syntax for a sequence twice, you get two sequences with equal contents.
604 There is one exception: the empty list @code{()} always stands for the
605 same object, @code{nil}.
608 @subsection Cons Cell and List Types
609 @cindex address field of register
610 @cindex decrement field of register
613 A @dfn{cons cell} is an object that consists of two slots, called the
614 @sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} or
615 @dfn{refer to} any Lisp object. We also say that ``the @sc{car} of
616 this cons cell is'' whatever object its @sc{car} slot currently holds,
617 and likewise for the @sc{cdr}.
620 A note to C programmers: in Lisp, we do not distinguish between
621 ``holding'' a value and ``pointing to'' the value, because pointers in
625 A @dfn{list} is a series of cons cells, linked together so that the
626 @sc{cdr} slot of each cons cell holds either the next cons cell or the
627 empty list. The empty list is actually the symbol @code{nil}.
628 @xref{Lists}, for functions that work on lists. Because most cons
629 cells are used as part of lists, the phrase @dfn{list structure} has
630 come to refer to any structure made out of cons cells.
633 Because cons cells are so central to Lisp, we also have a word for
634 ``an object which is not a cons cell''. These objects are called
638 @cindex @samp{(@dots{})} in lists
639 The read syntax and printed representation for lists are identical, and
640 consist of a left parenthesis, an arbitrary number of elements, and a
641 right parenthesis. Here are examples of lists:
644 (A 2 "A") ; @r{A list of three elements.}
645 () ; @r{A list of no elements (the empty list).}
646 nil ; @r{A list of no elements (the empty list).}
647 ("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
648 (A ()) ; @r{A list of two elements: @code{A} and the empty list.}
649 (A nil) ; @r{Equivalent to the previous.}
650 ((A B C)) ; @r{A list of one element}
651 ; @r{(which is a list of three elements).}
654 Upon reading, each object inside the parentheses becomes an element
655 of the list. That is, a cons cell is made for each element. The
656 @sc{car} slot of the cons cell holds the element, and its @sc{cdr}
657 slot refers to the next cons cell of the list, which holds the next
658 element in the list. The @sc{cdr} slot of the last cons cell is set to
661 The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
662 original Lisp implementation ran on an @w{IBM 704} computer which
663 divided words into two parts, called the ``address'' part and the
664 ``decrement''; @sc{car} was an instruction to extract the contents of
665 the address part of a register, and @sc{cdr} an instruction to extract
666 the contents of the decrement. By contrast, ``cons cells'' are named
667 for the function @code{cons} that creates them, which in turn was named
668 for its purpose, the construction of cells.
671 * Box Diagrams:: Drawing pictures of lists.
672 * Dotted Pair Notation:: A general syntax for cons cells.
673 * Association List Type:: A specially constructed list.
677 @subsubsection Drawing Lists as Box Diagrams
678 @cindex box diagrams, for lists
679 @cindex diagrams, boxed, for lists
681 A list can be illustrated by a diagram in which the cons cells are
682 shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
683 such an illustration; unlike the textual notation, which can be
684 understood by both humans and computers, the box illustrations can be
685 understood only by humans.) This picture represents the three-element
686 list @code{(rose violet buttercup)}:
690 --- --- --- --- --- ---
691 | | |--> | | |--> | | |--> nil
692 --- --- --- --- --- ---
695 --> rose --> violet --> buttercup
699 In this diagram, each box represents a slot that can hold or refer to
700 any Lisp object. Each pair of boxes represents a cons cell. Each arrow
701 represents a reference to a Lisp object, either an atom or another cons
704 In this example, the first box, which holds the @sc{car} of the first
705 cons cell, refers to or ``holds'' @code{rose} (a symbol). The second
706 box, holding the @sc{cdr} of the first cons cell, refers to the next
707 pair of boxes, the second cons cell. The @sc{car} of the second cons
708 cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
709 @sc{cdr} of the third (and last) cons cell is @code{nil}.
711 Here is another diagram of the same list, @code{(rose violet
712 buttercup)}, sketched in a different manner:
716 --------------- ---------------- -------------------
717 | car | cdr | | car | cdr | | car | cdr |
718 | rose | o-------->| violet | o-------->| buttercup | nil |
720 --------------- ---------------- -------------------
724 @cindex @code{nil} in lists
726 A list with no elements in it is the @dfn{empty list}; it is identical
727 to the symbol @code{nil}. In other words, @code{nil} is both a symbol
730 Here is the list @code{(A ())}, or equivalently @code{(A nil)},
731 depicted with boxes and arrows:
736 | | |--> | | |--> nil
744 Here is a more complex illustration, showing the three-element list,
745 @code{((pine needles) oak maple)}, the first element of which is a
750 --- --- --- --- --- ---
751 | | |--> | | |--> | | |--> nil
752 --- --- --- --- --- ---
758 --> | | |--> | | |--> nil
766 The same list represented in the second box notation looks like this:
770 -------------- -------------- --------------
771 | car | cdr | | car | cdr | | car | cdr |
772 | o | o------->| oak | o------->| maple | nil |
774 -- | --------- -------------- --------------
777 | -------------- ----------------
778 | | car | cdr | | car | cdr |
779 ------>| pine | o------->| needles | nil |
781 -------------- ----------------
785 @node Dotted Pair Notation
786 @subsubsection Dotted Pair Notation
787 @cindex dotted pair notation
788 @cindex @samp{.} in lists
790 @dfn{Dotted pair notation} is a general syntax for cons cells that
791 represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
792 @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
793 the object @var{a} and whose @sc{cdr} is the object @var{b}. Dotted
794 pair notation is more general than list syntax because the @sc{cdr}
795 does not have to be a list. However, it is more cumbersome in cases
796 where list syntax would work. In dotted pair notation, the list
797 @samp{(1 2 3)} is written as @samp{(1 . (2 . (3 . nil)))}. For
798 @code{nil}-terminated lists, you can use either notation, but list
799 notation is usually clearer and more convenient. When printing a
800 list, the dotted pair notation is only used if the @sc{cdr} of a cons
803 Here's an example using boxes to illustrate dotted pair notation.
804 This example shows the pair @code{(rose . violet)}:
817 You can combine dotted pair notation with list notation to represent
818 conveniently a chain of cons cells with a non-@code{nil} final @sc{cdr}.
819 You write a dot after the last element of the list, followed by the
820 @sc{cdr} of the final cons cell. For example, @code{(rose violet
821 . buttercup)} is equivalent to @code{(rose . (violet . buttercup))}.
822 The object looks like this:
827 | | |--> | | |--> buttercup
835 The syntax @code{(rose .@: violet .@: buttercup)} is invalid because
836 there is nothing that it could mean. If anything, it would say to put
837 @code{buttercup} in the @sc{cdr} of a cons cell whose @sc{cdr} is already
838 used for @code{violet}.
840 The list @code{(rose violet)} is equivalent to @code{(rose . (violet))},
846 | | |--> | | |--> nil
854 Similarly, the three-element list @code{(rose violet buttercup)}
855 is equivalent to @code{(rose . (violet . (buttercup)))}.
861 --- --- --- --- --- ---
862 | | |--> | | |--> | | |--> nil
863 --- --- --- --- --- ---
866 --> rose --> violet --> buttercup
871 @node Association List Type
872 @comment node-name, next, previous, up
873 @subsubsection Association List Type
875 An @dfn{association list} or @dfn{alist} is a specially-constructed
876 list whose elements are cons cells. In each element, the @sc{car} is
877 considered a @dfn{key}, and the @sc{cdr} is considered an
878 @dfn{associated value}. (In some cases, the associated value is stored
879 in the @sc{car} of the @sc{cdr}.) Association lists are often used as
880 stacks, since it is easy to add or remove associations at the front of
886 (setq alist-of-colors
887 '((rose . red) (lily . white) (buttercup . yellow)))
891 sets the variable @code{alist-of-colors} to an alist of three elements. In the
892 first element, @code{rose} is the key and @code{red} is the value.
894 @xref{Association Lists}, for a further explanation of alists and for
895 functions that work on alists. @xref{Hash Tables}, for another kind of
896 lookup table, which is much faster for handling a large number of keys.
899 @subsection Array Type
901 An @dfn{array} is composed of an arbitrary number of slots for
902 holding or referring to other Lisp objects, arranged in a contiguous block of
903 memory. Accessing any element of an array takes approximately the same
904 amount of time. In contrast, accessing an element of a list requires
905 time proportional to the position of the element in the list. (Elements
906 at the end of a list take longer to access than elements at the
907 beginning of a list.)
909 Emacs defines four types of array: strings, vectors, bool-vectors, and
912 A string is an array of characters and a vector is an array of
913 arbitrary objects. A bool-vector can hold only @code{t} or @code{nil}.
914 These kinds of array may have any length up to the largest integer.
915 Char-tables are sparse arrays indexed by any valid character code; they
916 can hold arbitrary objects.
918 The first element of an array has index zero, the second element has
919 index 1, and so on. This is called @dfn{zero-origin} indexing. For
920 example, an array of four elements has indices 0, 1, 2, @w{and 3}. The
921 largest possible index value is one less than the length of the array.
922 Once an array is created, its length is fixed.
924 All Emacs Lisp arrays are one-dimensional. (Most other programming
925 languages support multidimensional arrays, but they are not essential;
926 you can get the same effect with nested one-dimensional arrays.) Each
927 type of array has its own read syntax; see the following sections for
930 The array type is a subset of the sequence type, and contains the
931 string type, the vector type, the bool-vector type, and the char-table
935 @subsection String Type
937 A @dfn{string} is an array of characters. Strings are used for many
938 purposes in Emacs, as can be expected in a text editor; for example, as
939 the names of Lisp symbols, as messages for the user, and to represent
940 text extracted from buffers. Strings in Lisp are constants: evaluation
941 of a string returns the same string.
943 @xref{Strings and Characters}, for functions that operate on strings.
946 * Syntax for Strings::
947 * Non-ASCII in Strings::
948 * Nonprinting Characters::
949 * Text Props and Strings::
952 @node Syntax for Strings
953 @subsubsection Syntax for Strings
955 @cindex @samp{"} in strings
956 @cindex double-quote in strings
957 @cindex @samp{\} in strings
958 @cindex backslash in strings
959 The read syntax for strings is a double-quote, an arbitrary number of
960 characters, and another double-quote, @code{"like this"}. To include a
961 double-quote in a string, precede it with a backslash; thus, @code{"\""}
962 is a string containing just a single double-quote character. Likewise,
963 you can include a backslash by preceding it with another backslash, like
964 this: @code{"this \\ is a single embedded backslash"}.
966 @cindex newline in strings
967 The newline character is not special in the read syntax for strings;
968 if you write a new line between the double-quotes, it becomes a
969 character in the string. But an escaped newline---one that is preceded
970 by @samp{\}---does not become part of the string; i.e., the Lisp reader
971 ignores an escaped newline while reading a string. An escaped space
972 @w{@samp{\ }} is likewise ignored.
975 "It is useful to include newlines
976 in documentation strings,
979 @result{} "It is useful to include newlines
980 in documentation strings,
981 but the newline is ignored if escaped."
984 @node Non-ASCII in Strings
985 @subsubsection Non-@acronym{ASCII} Characters in Strings
987 You can include a non-@acronym{ASCII} international character in a string
988 constant by writing it literally. There are two text representations
989 for non-@acronym{ASCII} characters in Emacs strings (and in buffers): unibyte
990 and multibyte. If the string constant is read from a multibyte source,
991 such as a multibyte buffer or string, or a file that would be visited as
992 multibyte, then the character is read as a multibyte character, and that
993 makes the string multibyte. If the string constant is read from a
994 unibyte source, then the character is read as unibyte and that makes the
997 You can also represent a multibyte non-@acronym{ASCII} character with its
998 character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many
999 digits as necessary. (Multibyte non-@acronym{ASCII} character codes are all
1000 greater than 256.) Any character which is not a valid hex digit
1001 terminates this construct. If the next character in the string could be
1002 interpreted as a hex digit, write @w{@samp{\ }} (backslash and space) to
1003 terminate the hex escape---for example, @w{@samp{\x8e0\ }} represents
1004 one character, @samp{a} with grave accent. @w{@samp{\ }} in a string
1005 constant is just like backslash-newline; it does not contribute any
1006 character to the string, but it does terminate the preceding hex escape.
1008 You can represent a unibyte non-@acronym{ASCII} character with its
1009 character code, which must be in the range from 128 (0200 octal) to
1010 255 (0377 octal). If you write all such character codes in octal and
1011 the string contains no other characters forcing it to be multibyte,
1012 this produces a unibyte string. However, using any hex escape in a
1013 string (even for an @acronym{ASCII} character) forces the string to be
1016 You can also specify characters in a string by their numeric values
1017 in Unicode, using @samp{\u} and @samp{\U} (@pxref{Character Type}).
1019 @xref{Text Representations}, for more information about the two
1020 text representations.
1022 @node Nonprinting Characters
1023 @subsubsection Nonprinting Characters in Strings
1025 You can use the same backslash escape-sequences in a string constant
1026 as in character literals (but do not use the question mark that begins a
1027 character constant). For example, you can write a string containing the
1028 nonprinting characters tab and @kbd{C-a}, with commas and spaces between
1029 them, like this: @code{"\t, \C-a"}. @xref{Character Type}, for a
1030 description of the read syntax for characters.
1032 However, not all of the characters you can write with backslash
1033 escape-sequences are valid in strings. The only control characters that
1034 a string can hold are the @acronym{ASCII} control characters. Strings do not
1035 distinguish case in @acronym{ASCII} control characters.
1037 Properly speaking, strings cannot hold meta characters; but when a
1038 string is to be used as a key sequence, there is a special convention
1039 that provides a way to represent meta versions of @acronym{ASCII}
1040 characters in a string. If you use the @samp{\M-} syntax to indicate
1041 a meta character in a string constant, this sets the
1048 bit of the character in the string. If the string is used in
1049 @code{define-key} or @code{lookup-key}, this numeric code is translated
1050 into the equivalent meta character. @xref{Character Type}.
1052 Strings cannot hold characters that have the hyper, super, or alt
1055 @node Text Props and Strings
1056 @subsubsection Text Properties in Strings
1058 A string can hold properties for the characters it contains, in
1059 addition to the characters themselves. This enables programs that copy
1060 text between strings and buffers to copy the text's properties with no
1061 special effort. @xref{Text Properties}, for an explanation of what text
1062 properties mean. Strings with text properties use a special read and
1066 #("@var{characters}" @var{property-data}...)
1070 where @var{property-data} consists of zero or more elements, in groups
1071 of three as follows:
1074 @var{beg} @var{end} @var{plist}
1078 The elements @var{beg} and @var{end} are integers, and together specify
1079 a range of indices in the string; @var{plist} is the property list for
1080 that range. For example,
1083 #("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))
1087 represents a string whose textual contents are @samp{foo bar}, in which
1088 the first three characters have a @code{face} property with value
1089 @code{bold}, and the last three have a @code{face} property with value
1090 @code{italic}. (The fourth character has no text properties, so its
1091 property list is @code{nil}. It is not actually necessary to mention
1092 ranges with @code{nil} as the property list, since any characters not
1093 mentioned in any range will default to having no properties.)
1096 @subsection Vector Type
1098 A @dfn{vector} is a one-dimensional array of elements of any type. It
1099 takes a constant amount of time to access any element of a vector. (In
1100 a list, the access time of an element is proportional to the distance of
1101 the element from the beginning of the list.)
1103 The printed representation of a vector consists of a left square
1104 bracket, the elements, and a right square bracket. This is also the
1105 read syntax. Like numbers and strings, vectors are considered constants
1109 [1 "two" (three)] ; @r{A vector of three elements.}
1110 @result{} [1 "two" (three)]
1113 @xref{Vectors}, for functions that work with vectors.
1115 @node Char-Table Type
1116 @subsection Char-Table Type
1118 A @dfn{char-table} is a one-dimensional array of elements of any type,
1119 indexed by character codes. Char-tables have certain extra features to
1120 make them more useful for many jobs that involve assigning information
1121 to character codes---for example, a char-table can have a parent to
1122 inherit from, a default value, and a small number of extra slots to use for
1123 special purposes. A char-table can also specify a single value for
1124 a whole character set.
1126 The printed representation of a char-table is like a vector
1127 except that there is an extra @samp{#^} at the beginning.
1129 @xref{Char-Tables}, for special functions to operate on char-tables.
1130 Uses of char-tables include:
1134 Case tables (@pxref{Case Tables}).
1137 Character category tables (@pxref{Categories}).
1140 Display tables (@pxref{Display Tables}).
1143 Syntax tables (@pxref{Syntax Tables}).
1146 @node Bool-Vector Type
1147 @subsection Bool-Vector Type
1149 A @dfn{bool-vector} is a one-dimensional array of elements that
1150 must be @code{t} or @code{nil}.
1152 The printed representation of a bool-vector is like a string, except
1153 that it begins with @samp{#&} followed by the length. The string
1154 constant that follows actually specifies the contents of the bool-vector
1155 as a bitmap---each ``character'' in the string contains 8 bits, which
1156 specify the next 8 elements of the bool-vector (1 stands for @code{t},
1157 and 0 for @code{nil}). The least significant bits of the character
1158 correspond to the lowest indices in the bool-vector.
1161 (make-bool-vector 3 t)
1163 (make-bool-vector 3 nil)
1168 These results make sense, because the binary code for @samp{C-g} is
1169 111 and @samp{C-@@} is the character with code 0.
1171 If the length is not a multiple of 8, the printed representation
1172 shows extra elements, but these extras really make no difference. For
1173 instance, in the next example, the two bool-vectors are equal, because
1174 only the first 3 bits are used:
1177 (equal #&3"\377" #&3"\007")
1181 @node Hash Table Type
1182 @subsection Hash Table Type
1184 A hash table is a very fast kind of lookup table, somewhat like an
1185 alist in that it maps keys to corresponding values, but much faster.
1186 Hash tables have no read syntax, and print using hash notation.
1187 @xref{Hash Tables}, for functions that operate on hash tables.
1191 @result{} #<hash-table 'eql nil 0/65 0x83af980>
1195 @subsection Function Type
1197 Just as functions in other programming languages are executable,
1198 @dfn{Lisp function} objects are pieces of executable code. However,
1199 functions in Lisp are primarily Lisp objects, and only secondarily the
1200 text which represents them. These Lisp objects are lambda expressions:
1201 lists whose first element is the symbol @code{lambda} (@pxref{Lambda
1204 In most programming languages, it is impossible to have a function
1205 without a name. In Lisp, a function has no intrinsic name. A lambda
1206 expression is also called an @dfn{anonymous function} (@pxref{Anonymous
1207 Functions}). A named function in Lisp is actually a symbol with a valid
1208 function in its function cell (@pxref{Defining Functions}).
1210 Most of the time, functions are called when their names are written in
1211 Lisp expressions in Lisp programs. However, you can construct or obtain
1212 a function object at run time and then call it with the primitive
1213 functions @code{funcall} and @code{apply}. @xref{Calling Functions}.
1216 @subsection Macro Type
1218 A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
1219 language. It is represented as an object much like a function, but with
1220 different argument-passing semantics. A Lisp macro has the form of a
1221 list whose first element is the symbol @code{macro} and whose @sc{cdr}
1222 is a Lisp function object, including the @code{lambda} symbol.
1224 Lisp macro objects are usually defined with the built-in
1225 @code{defmacro} function, but any list that begins with @code{macro} is
1226 a macro as far as Emacs is concerned. @xref{Macros}, for an explanation
1227 of how to write a macro.
1229 @strong{Warning}: Lisp macros and keyboard macros (@pxref{Keyboard
1230 Macros}) are entirely different things. When we use the word ``macro''
1231 without qualification, we mean a Lisp macro, not a keyboard macro.
1233 @node Primitive Function Type
1234 @subsection Primitive Function Type
1235 @cindex special forms
1237 A @dfn{primitive function} is a function callable from Lisp but
1238 written in the C programming language. Primitive functions are also
1239 called @dfn{subrs} or @dfn{built-in functions}. (The word ``subr'' is
1240 derived from ``subroutine''.) Most primitive functions evaluate all
1241 their arguments when they are called. A primitive function that does
1242 not evaluate all its arguments is called a @dfn{special form}
1243 (@pxref{Special Forms}).@refill
1245 It does not matter to the caller of a function whether the function is
1246 primitive. However, this does matter if you try to redefine a primitive
1247 with a function written in Lisp. The reason is that the primitive
1248 function may be called directly from C code. Calls to the redefined
1249 function from Lisp will use the new definition, but calls from C code
1250 may still use the built-in definition. Therefore, @strong{we discourage
1251 redefinition of primitive functions}.
1253 The term @dfn{function} refers to all Emacs functions, whether written
1254 in Lisp or C. @xref{Function Type}, for information about the
1255 functions written in Lisp.
1257 Primitive functions have no read syntax and print in hash notation
1258 with the name of the subroutine.
1262 (symbol-function 'car) ; @r{Access the function cell}
1263 ; @r{of the symbol.}
1264 @result{} #<subr car>
1265 (subrp (symbol-function 'car)) ; @r{Is this a primitive function?}
1266 @result{} t ; @r{Yes.}
1270 @node Byte-Code Type
1271 @subsection Byte-Code Function Type
1273 The byte compiler produces @dfn{byte-code function objects}.
1274 Internally, a byte-code function object is much like a vector; however,
1275 the evaluator handles this data type specially when it appears as a
1276 function to be called. @xref{Byte Compilation}, for information about
1279 The printed representation and read syntax for a byte-code function
1280 object is like that for a vector, with an additional @samp{#} before the
1284 @subsection Autoload Type
1286 An @dfn{autoload object} is a list whose first element is the symbol
1287 @code{autoload}. It is stored as the function definition of a symbol,
1288 where it serves as a placeholder for the real definition. The autoload
1289 object says that the real definition is found in a file of Lisp code
1290 that should be loaded when necessary. It contains the name of the file,
1291 plus some other information about the real definition.
1293 After the file has been loaded, the symbol should have a new function
1294 definition that is not an autoload object. The new definition is then
1295 called as if it had been there to begin with. From the user's point of
1296 view, the function call works as expected, using the function definition
1299 An autoload object is usually created with the function
1300 @code{autoload}, which stores the object in the function cell of a
1301 symbol. @xref{Autoload}, for more details.
1304 @section Editing Types
1305 @cindex editing types
1307 The types in the previous section are used for general programming
1308 purposes, and most of them are common to most Lisp dialects. Emacs Lisp
1309 provides several additional data types for purposes connected with
1313 * Buffer Type:: The basic object of editing.
1314 * Marker Type:: A position in a buffer.
1315 * Window Type:: Buffers are displayed in windows.
1316 * Frame Type:: Windows subdivide frames.
1317 * Window Configuration Type:: Recording the way a frame is subdivided.
1318 * Frame Configuration Type:: Recording the status of all frames.
1319 * Process Type:: A process running on the underlying OS.
1320 * Stream Type:: Receive or send characters.
1321 * Keymap Type:: What function a keystroke invokes.
1322 * Overlay Type:: How an overlay is represented.
1326 @subsection Buffer Type
1328 A @dfn{buffer} is an object that holds text that can be edited
1329 (@pxref{Buffers}). Most buffers hold the contents of a disk file
1330 (@pxref{Files}) so they can be edited, but some are used for other
1331 purposes. Most buffers are also meant to be seen by the user, and
1332 therefore displayed, at some time, in a window (@pxref{Windows}). But a
1333 buffer need not be displayed in any window.
1335 The contents of a buffer are much like a string, but buffers are not
1336 used like strings in Emacs Lisp, and the available operations are
1337 different. For example, you can insert text efficiently into an
1338 existing buffer, altering the buffer's contents, whereas ``inserting''
1339 text into a string requires concatenating substrings, and the result is
1340 an entirely new string object.
1342 Each buffer has a designated position called @dfn{point}
1343 (@pxref{Positions}). At any time, one buffer is the @dfn{current
1344 buffer}. Most editing commands act on the contents of the current
1345 buffer in the neighborhood of point. Many of the standard Emacs
1346 functions manipulate or test the characters in the current buffer; a
1347 whole chapter in this manual is devoted to describing these functions
1350 Several other data structures are associated with each buffer:
1354 a local syntax table (@pxref{Syntax Tables});
1357 a local keymap (@pxref{Keymaps}); and,
1360 a list of buffer-local variable bindings (@pxref{Buffer-Local Variables}).
1363 overlays (@pxref{Overlays}).
1366 text properties for the text in the buffer (@pxref{Text Properties}).
1370 The local keymap and variable list contain entries that individually
1371 override global bindings or values. These are used to customize the
1372 behavior of programs in different buffers, without actually changing the
1375 A buffer may be @dfn{indirect}, which means it shares the text
1376 of another buffer, but presents it differently. @xref{Indirect Buffers}.
1378 Buffers have no read syntax. They print in hash notation, showing the
1384 @result{} #<buffer objects.texi>
1389 @subsection Marker Type
1391 A @dfn{marker} denotes a position in a specific buffer. Markers
1392 therefore have two components: one for the buffer, and one for the
1393 position. Changes in the buffer's text automatically relocate the
1394 position value as necessary to ensure that the marker always points
1395 between the same two characters in the buffer.
1397 Markers have no read syntax. They print in hash notation, giving the
1398 current character position and the name of the buffer.
1403 @result{} #<marker at 10779 in objects.texi>
1407 @xref{Markers}, for information on how to test, create, copy, and move
1411 @subsection Window Type
1413 A @dfn{window} describes the portion of the terminal screen that Emacs
1414 uses to display a buffer. Every window has one associated buffer, whose
1415 contents appear in the window. By contrast, a given buffer may appear
1416 in one window, no window, or several windows.
1418 Though many windows may exist simultaneously, at any time one window
1419 is designated the @dfn{selected window}. This is the window where the
1420 cursor is (usually) displayed when Emacs is ready for a command. The
1421 selected window usually displays the current buffer, but this is not
1422 necessarily the case.
1424 Windows are grouped on the screen into frames; each window belongs to
1425 one and only one frame. @xref{Frame Type}.
1427 Windows have no read syntax. They print in hash notation, giving the
1428 window number and the name of the buffer being displayed. The window
1429 numbers exist to identify windows uniquely, since the buffer displayed
1430 in any given window can change frequently.
1435 @result{} #<window 1 on objects.texi>
1439 @xref{Windows}, for a description of the functions that work on windows.
1442 @subsection Frame Type
1444 A @dfn{frame} is a rectangle on the screen that contains one or more
1445 Emacs windows. A frame initially contains a single main window (plus
1446 perhaps a minibuffer window) which you can subdivide vertically or
1447 horizontally into smaller windows.
1449 Frames have no read syntax. They print in hash notation, giving the
1450 frame's title, plus its address in core (useful to identify the frame
1456 @result{} #<frame emacs@@psilocin.gnu.org 0xdac80>
1460 @xref{Frames}, for a description of the functions that work on frames.
1462 @node Window Configuration Type
1463 @subsection Window Configuration Type
1464 @cindex screen layout
1466 A @dfn{window configuration} stores information about the positions,
1467 sizes, and contents of the windows in a frame, so you can recreate the
1468 same arrangement of windows later.
1470 Window configurations do not have a read syntax; their print syntax
1471 looks like @samp{#<window-configuration>}. @xref{Window
1472 Configurations}, for a description of several functions related to
1473 window configurations.
1475 @node Frame Configuration Type
1476 @subsection Frame Configuration Type
1477 @cindex screen layout
1479 A @dfn{frame configuration} stores information about the positions,
1480 sizes, and contents of the windows in all frames. It is actually
1481 a list whose @sc{car} is @code{frame-configuration} and whose
1482 @sc{cdr} is an alist. Each alist element describes one frame,
1483 which appears as the @sc{car} of that element.
1485 @xref{Frame Configurations}, for a description of several functions
1486 related to frame configurations.
1489 @subsection Process Type
1491 The word @dfn{process} usually means a running program. Emacs itself
1492 runs in a process of this sort. However, in Emacs Lisp, a process is a
1493 Lisp object that designates a subprocess created by the Emacs process.
1494 Programs such as shells, GDB, ftp, and compilers, running in
1495 subprocesses of Emacs, extend the capabilities of Emacs.
1497 An Emacs subprocess takes textual input from Emacs and returns textual
1498 output to Emacs for further manipulation. Emacs can also send signals
1501 Process objects have no read syntax. They print in hash notation,
1502 giving the name of the process:
1507 @result{} (#<process shell>)
1511 @xref{Processes}, for information about functions that create, delete,
1512 return information about, send input or signals to, and receive output
1516 @subsection Stream Type
1518 A @dfn{stream} is an object that can be used as a source or sink for
1519 characters---either to supply characters for input or to accept them as
1520 output. Many different types can be used this way: markers, buffers,
1521 strings, and functions. Most often, input streams (character sources)
1522 obtain characters from the keyboard, a buffer, or a file, and output
1523 streams (character sinks) send characters to a buffer, such as a
1524 @file{*Help*} buffer, or to the echo area.
1526 The object @code{nil}, in addition to its other meanings, may be used
1527 as a stream. It stands for the value of the variable
1528 @code{standard-input} or @code{standard-output}. Also, the object
1529 @code{t} as a stream specifies input using the minibuffer
1530 (@pxref{Minibuffers}) or output in the echo area (@pxref{The Echo
1533 Streams have no special printed representation or read syntax, and
1534 print as whatever primitive type they are.
1536 @xref{Read and Print}, for a description of functions
1537 related to streams, including parsing and printing functions.
1540 @subsection Keymap Type
1542 A @dfn{keymap} maps keys typed by the user to commands. This mapping
1543 controls how the user's command input is executed. A keymap is actually
1544 a list whose @sc{car} is the symbol @code{keymap}.
1546 @xref{Keymaps}, for information about creating keymaps, handling prefix
1547 keys, local as well as global keymaps, and changing key bindings.
1550 @subsection Overlay Type
1552 An @dfn{overlay} specifies properties that apply to a part of a
1553 buffer. Each overlay applies to a specified range of the buffer, and
1554 contains a property list (a list whose elements are alternating property
1555 names and values). Overlay properties are used to present parts of the
1556 buffer temporarily in a different display style. Overlays have no read
1557 syntax, and print in hash notation, giving the buffer name and range of
1560 @xref{Overlays}, for how to create and use overlays.
1562 @node Circular Objects
1563 @section Read Syntax for Circular Objects
1564 @cindex circular structure, read syntax
1565 @cindex shared structure, read syntax
1566 @cindex @samp{#@var{n}=} read syntax
1567 @cindex @samp{#@var{n}#} read syntax
1569 To represent shared or circular structures within a complex of Lisp
1570 objects, you can use the reader constructs @samp{#@var{n}=} and
1573 Use @code{#@var{n}=} before an object to label it for later reference;
1574 subsequently, you can use @code{#@var{n}#} to refer the same object in
1575 another place. Here, @var{n} is some integer. For example, here is how
1576 to make a list in which the first element recurs as the third element:
1583 This differs from ordinary syntax such as this
1590 which would result in a list whose first and third elements
1591 look alike but are not the same Lisp object. This shows the difference:
1595 (setq x '(#1=(a) b #1#)))
1596 (eq (nth 0 x) (nth 2 x))
1598 (setq x '((a) b (a)))
1599 (eq (nth 0 x) (nth 2 x))
1603 You can also use the same syntax to make a circular structure, which
1604 appears as an ``element'' within itself. Here is an example:
1611 This makes a list whose second element is the list itself.
1612 Here's how you can see that it really works:
1616 (setq x '#1=(a #1#)))
1621 The Lisp printer can produce this syntax to record circular and shared
1622 structure in a Lisp object, if you bind the variable @code{print-circle}
1623 to a non-@code{nil} value. @xref{Output Variables}.
1625 @node Type Predicates
1626 @section Type Predicates
1627 @cindex type checking
1628 @kindex wrong-type-argument
1630 The Emacs Lisp interpreter itself does not perform type checking on
1631 the actual arguments passed to functions when they are called. It could
1632 not do so, since function arguments in Lisp do not have declared data
1633 types, as they do in other programming languages. It is therefore up to
1634 the individual function to test whether each actual argument belongs to
1635 a type that the function can use.
1637 All built-in functions do check the types of their actual arguments
1638 when appropriate, and signal a @code{wrong-type-argument} error if an
1639 argument is of the wrong type. For example, here is what happens if you
1640 pass an argument to @code{+} that it cannot handle:
1645 @error{} Wrong type argument: number-or-marker-p, a
1649 @cindex type predicates
1650 @cindex testing types
1651 If you want your program to handle different types differently, you
1652 must do explicit type checking. The most common way to check the type
1653 of an object is to call a @dfn{type predicate} function. Emacs has a
1654 type predicate for each type, as well as some predicates for
1655 combinations of types.
1657 A type predicate function takes one argument; it returns @code{t} if
1658 the argument belongs to the appropriate type, and @code{nil} otherwise.
1659 Following a general Lisp convention for predicate functions, most type
1660 predicates' names end with @samp{p}.
1662 Here is an example which uses the predicates @code{listp} to check for
1663 a list and @code{symbolp} to check for a symbol.
1668 ;; If X is a symbol, put it on LIST.
1669 (setq list (cons x list)))
1671 ;; If X is a list, add its elements to LIST.
1672 (setq list (append x list)))
1674 ;; We handle only symbols and lists.
1675 (error "Invalid argument %s in add-on" x))))
1678 Here is a table of predefined type predicates, in alphabetical order,
1679 with references to further information.
1683 @xref{List-related Predicates, atom}.
1686 @xref{Array Functions, arrayp}.
1689 @xref{Bool-Vectors, bool-vector-p}.
1692 @xref{Buffer Basics, bufferp}.
1694 @item byte-code-function-p
1695 @xref{Byte-Code Type, byte-code-function-p}.
1698 @xref{Case Tables, case-table-p}.
1700 @item char-or-string-p
1701 @xref{Predicates for Strings, char-or-string-p}.
1704 @xref{Char-Tables, char-table-p}.
1707 @xref{Interactive Call, commandp}.
1710 @xref{List-related Predicates, consp}.
1712 @item display-table-p
1713 @xref{Display Tables, display-table-p}.
1716 @xref{Predicates on Numbers, floatp}.
1718 @item frame-configuration-p
1719 @xref{Frame Configurations, frame-configuration-p}.
1722 @xref{Deleting Frames, frame-live-p}.
1725 @xref{Frames, framep}.
1728 @xref{Functions, functionp}.
1731 @xref{Other Hash, hash-table-p}.
1733 @item integer-or-marker-p
1734 @xref{Predicates on Markers, integer-or-marker-p}.
1737 @xref{Predicates on Numbers, integerp}.
1740 @xref{Creating Keymaps, keymapp}.
1743 @xref{Constant Variables}.
1746 @xref{List-related Predicates, listp}.
1749 @xref{Predicates on Markers, markerp}.
1752 @xref{Predicates on Numbers, wholenump}.
1755 @xref{List-related Predicates, nlistp}.
1758 @xref{Predicates on Numbers, numberp}.
1760 @item number-or-marker-p
1761 @xref{Predicates on Markers, number-or-marker-p}.
1764 @xref{Overlays, overlayp}.
1767 @xref{Processes, processp}.
1770 @xref{Sequence Functions, sequencep}.
1773 @xref{Predicates for Strings, stringp}.
1776 @xref{Function Cells, subrp}.
1779 @xref{Symbols, symbolp}.
1781 @item syntax-table-p
1782 @xref{Syntax Tables, syntax-table-p}.
1784 @item user-variable-p
1785 @xref{Defining Variables, user-variable-p}.
1788 @xref{Vectors, vectorp}.
1790 @item window-configuration-p
1791 @xref{Window Configurations, window-configuration-p}.
1794 @xref{Deleting Windows, window-live-p}.
1797 @xref{Basic Windows, windowp}.
1800 @xref{nil and t, booleanp}.
1802 @item string-or-null-p
1803 @xref{Predicates for Strings, string-or-null-p}.
1806 The most general way to check the type of an object is to call the
1807 function @code{type-of}. Recall that each object belongs to one and
1808 only one primitive type; @code{type-of} tells you which one (@pxref{Lisp
1809 Data Types}). But @code{type-of} knows nothing about non-primitive
1810 types. In most cases, it is more convenient to use type predicates than
1813 @defun type-of object
1814 This function returns a symbol naming the primitive type of
1815 @var{object}. The value is one of the symbols @code{symbol},
1816 @code{integer}, @code{float}, @code{string}, @code{cons}, @code{vector},
1817 @code{char-table}, @code{bool-vector}, @code{hash-table}, @code{subr},
1818 @code{compiled-function}, @code{marker}, @code{overlay}, @code{window},
1819 @code{buffer}, @code{frame}, @code{process}, or
1820 @code{window-configuration}.
1827 (type-of '()) ; @r{@code{()} is @code{nil}.}
1834 @node Equality Predicates
1835 @section Equality Predicates
1838 Here we describe two functions that test for equality between any two
1839 objects. Other functions test equality between objects of specific
1840 types, e.g., strings. For these predicates, see the appropriate chapter
1841 describing the data type.
1843 @defun eq object1 object2
1844 This function returns @code{t} if @var{object1} and @var{object2} are
1845 the same object, @code{nil} otherwise.
1847 @code{eq} returns @code{t} if @var{object1} and @var{object2} are
1848 integers with the same value. Also, since symbol names are normally
1849 unique, if the arguments are symbols with the same name, they are
1850 @code{eq}. For other types (e.g., lists, vectors, strings), two
1851 arguments with the same contents or elements are not necessarily
1852 @code{eq} to each other: they are @code{eq} only if they are the same
1853 object, meaning that a change in the contents of one will be reflected
1854 by the same change in the contents of the other.
1873 (eq '(1 (2 (3))) '(1 (2 (3))))
1878 (setq foo '(1 (2 (3))))
1879 @result{} (1 (2 (3)))
1882 (eq foo '(1 (2 (3))))
1887 (eq [(1 2) 3] [(1 2) 3])
1892 (eq (point-marker) (point-marker))
1897 The @code{make-symbol} function returns an uninterned symbol, distinct
1898 from the symbol that is used if you write the name in a Lisp expression.
1899 Distinct symbols with the same name are not @code{eq}. @xref{Creating
1904 (eq (make-symbol "foo") 'foo)
1910 @defun equal object1 object2
1911 This function returns @code{t} if @var{object1} and @var{object2} have
1912 equal components, @code{nil} otherwise. Whereas @code{eq} tests if its
1913 arguments are the same object, @code{equal} looks inside nonidentical
1914 arguments to see if their elements or contents are the same. So, if two
1915 objects are @code{eq}, they are @code{equal}, but the converse is not
1930 (equal "asdf" "asdf")
1939 (equal '(1 (2 (3))) '(1 (2 (3))))
1943 (eq '(1 (2 (3))) '(1 (2 (3))))
1948 (equal [(1 2) 3] [(1 2) 3])
1952 (eq [(1 2) 3] [(1 2) 3])
1957 (equal (point-marker) (point-marker))
1962 (eq (point-marker) (point-marker))
1967 @cindex equality of strings
1968 Comparison of strings is case-sensitive, but does not take account of
1969 text properties---it compares only the characters in the strings. For
1970 technical reasons, a unibyte string and a multibyte string are
1971 @code{equal} if and only if they contain the same sequence of
1972 character codes and all these codes are either in the range 0 through
1973 127 (@acronym{ASCII}) or 160 through 255 (@code{eight-bit-graphic}).
1974 (@pxref{Text Representations}).
1978 (equal "asdf" "ASDF")
1983 However, two distinct buffers are never considered @code{equal}, even if
1984 their textual contents are the same.
1987 The test for equality is implemented recursively; for example, given
1988 two cons cells @var{x} and @var{y}, @code{(equal @var{x} @var{y})}
1989 returns @code{t} if and only if both the expressions below return
1993 (equal (car @var{x}) (car @var{y}))
1994 (equal (cdr @var{x}) (cdr @var{y}))
1997 Because of this recursive method, circular lists may therefore cause
1998 infinite recursion (leading to an error).
2001 arch-tag: 9711a66e-4749-4265-9e8c-972d55b67096