@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
+@c Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/objects
@node Lisp Data Types, Numbers, Introduction, Top
@cindex primitive type
A few fundamental object types are built into Emacs. These, from
-which all other types are constructed, are called @dfn{primitive
-types}. Each object belongs to one and only one primitive type. These
-types include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
-@dfn{string}, @dfn{vector}, @dfn{subr}, @dfn{byte-code function}, plus
-several special types, such as @dfn{buffer}, that are related to
-editing. (@xref{Editing Types}.)
+which all other types are constructed, are called @dfn{primitive types}.
+Each object belongs to one and only one primitive type. These types
+include @dfn{integer}, @dfn{float}, @dfn{cons}, @dfn{symbol},
+@dfn{string}, @dfn{vector}, @dfn{hash-table}, @dfn{subr}, and
+@dfn{byte-code function}, plus several special types, such as
+@dfn{buffer}, that are related to editing. (@xref{Editing Types}.)
Each primitive type has a corresponding Lisp function that checks
whether an object is a member of that type.
* Comments:: Comments and their formatting conventions.
* Programming Types:: Types found in all Lisp systems.
* Editing Types:: Types specific to Emacs.
+* Circular Objects:: Read syntax for circular structure.
* Type Predicates:: Tests related to types.
* Equality Predicates:: Tests of equality between any two objects.
@end menu
* Vector Type:: One-dimensional arrays.
* Char-Table Type:: One-dimensional sparse arrays indexed by characters.
* Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
+* Hash Table Type:: Super-fast lookup tables.
* Function Type:: A piece of executable code you can call from elsewhere.
* Macro Type:: A method of expanding an expression into another
expression, more fundamental but less pretty.
The range of values for integers in Emacs Lisp is @minus{}134217728 to
134217727 (28 bits; i.e.,
-@ifinfo
+@ifnottex
-2**27
-@end ifinfo
+@end ifnottex
@tex
-$-2^{27}$
+@math{-2^{27}}
@end tex
to
-@ifinfo
+@ifnottex
2**27 - 1)
-@end ifinfo
+@end ifnottex
@tex
-$2^{28}-1$)
+@math{2^{28}-1})
@end tex
on most machines. (Some machines may provide a wider range.) It is
important to note that the Emacs Lisp arithmetic functions do not check
@group
-1 ; @r{The integer -1.}
1 ; @r{The integer 1.}
-1. ; @r{Also The integer 1.}
+1. ; @r{Also the integer 1.}
+1 ; @r{Also the integer 1.}
268435457 ; @r{Also the integer 1 on a 28-bit implementation.}
@end group
@node Character Type
@subsection Character Type
-@cindex @sc{ASCII} character codes
+@cindex @sc{ascii} character codes
A @dfn{character} in Emacs Lisp is nothing more than an integer. In
other words, characters are represented by their character codes. For
Characters in strings, buffers, and files are currently limited to the
range of 0 to 524287---nineteen bits. But not all values in that range
-are valid character codes. Codes 0 through 127 are ASCII codes; the
-rest are non-ASCII (@pxref{Non-ASCII Characters}). Characters that represent
+are valid character codes. Codes 0 through 127 are @sc{ascii} codes; the
+rest are non-@sc{ascii} (@pxref{Non-ASCII Characters}). Characters that represent
keyboard input have a much wider range, to encode modifier keys such as
Control, Meta and Shift.
@cindex read syntax for characters
@cindex printed representation for characters
@cindex syntax for characters
+@cindex @samp{?} in character constant
+@cindex question mark in character constant
Since characters are really integers, the printed representation of a
character is a decimal number. This is also a possible read syntax for
a character, but writing characters that way in Lisp programs is a very
?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
+?\d @result{} 127 ; @r{delete character, @key{DEL}}
@end example
@cindex escape sequence
@end example
In strings and buffers, the only control characters allowed are those
-that exist in @sc{ASCII}; but for keyboard input purposes, you can turn
+that exist in @sc{ascii}; but for keyboard input purposes, you can turn
any character into a control character with @samp{C-}. The character
-codes for these non-@sc{ASCII} control characters include the
+codes for these non-@sc{ascii} control characters include the
@tex
-$2^{26}$
+@math{2^{26}}
@end tex
-@ifinfo
+@ifnottex
2**26
-@end ifinfo
+@end ifnottex
bit as well as the code for the corresponding non-control
-character. Ordinary terminals have no way of generating non-@sc{ASCII}
+character. Ordinary terminals have no way of generating non-@sc{ascii}
control characters, but you can generate them straightforwardly using X
and other window systems.
A @dfn{meta character} is a character typed with the @key{META}
modifier key. The integer that represents such a character has the
@tex
-$2^{27}$
+@math{2^{27}}
@end tex
-@ifinfo
+@ifnottex
2**27
-@end ifinfo
+@end ifnottex
bit set (which on most machines makes it a negative number). We
use high bits for this and other modifiers to make possible a wide range
of basic character codes.
In a string, the
@tex
-$2^{7}$
+@math{2^{7}}
@end tex
-@ifinfo
+@ifnottex
2**7
-@end ifinfo
-bit attached to an ASCII character indicates a meta character; thus, the
+@end ifnottex
+bit attached to an @sc{ascii} character indicates a meta character; thus, the
meta characters that can fit in a string have codes in the range from
-128 to 255, and are the meta versions of the ordinary @sc{ASCII}
+128 to 255, and are the meta versions of the ordinary @sc{ascii}
characters. (In Emacs versions 18 and older, this convention was used
for characters outside of strings as well.)
@samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
The case of a graphic character is indicated by its character code;
-for example, @sc{ASCII} distinguishes between the characters @samp{a}
-and @samp{A}. But @sc{ASCII} has no way to represent whether a control
+for example, @sc{ascii} distinguishes between the characters @samp{a}
+and @samp{A}. But @sc{ascii} has no way to represent whether a control
character is upper case or lower case. Emacs uses the
@tex
-$2^{25}$
+@math{2^{25}}
@end tex
-@ifinfo
+@ifnottex
2**25
-@end ifinfo
+@end ifnottex
bit to indicate that the shift key was used in typing a control
character. This distinction is possible only when you use X terminals
or other special terminals; ordinary terminals do not report the
-distinction to the computer in any way.
+distinction to the computer in any way. The Lisp syntax for
+the shift bit is @samp{\S-}; thus, @samp{?\C-\S-o} or @samp{?\C-\S-O}
+represents the shifted-control-o character.
@cindex hyper characters
@cindex super characters
@kbd{Alt-Hyper-Meta-x}.
@tex
Numerically, the
-bit values are $2^{22}$ for alt, $2^{23}$ for super and $2^{24}$ for hyper.
+bit values are @math{2^{22}} for alt, @math{2^{23}} for super and @math{2^{24}} for hyper.
@end tex
-@ifinfo
+@ifnottex
Numerically, the
bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
-@end ifinfo
+@end ifnottex
-@cindex @samp{?} in character constant
-@cindex question mark in character constant
@cindex @samp{\} in character constant
@cindex backslash in character constant
@cindex octal character code
mark followed by a backslash and the octal character code (up to three
octal digits); thus, @samp{?\101} for the character @kbd{A},
@samp{?\001} for the character @kbd{C-a}, and @code{?\002} for the
-character @kbd{C-b}. Although this syntax can represent any @sc{ASCII}
+character @kbd{C-b}. Although this syntax can represent any @sc{ascii}
character, it is preferred only when the precise octal value is more
-important than the @sc{ASCII} representation.
+important than the @sc{ascii} representation.
@example
@group
@iftex
@samp{@`a}.
@end iftex
-@ifinfo
+@ifnottex
@samp{a} with grave accent.
-@end ifinfo
+@end ifnottex
A backslash is allowed, and harmless, preceding any character without
a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
intended. But you can use one symbol in all of these ways,
independently.
+ A symbol whose name starts with a colon (@samp{:}) is called a
+@dfn{keyword symbol}. These symbols automatically act as constants, and
+are normally used only by comparing an unknown symbol with a few
+specific alternatives.
+
@cindex @samp{\} in symbols
@cindex backslash in symbols
A symbol name can contain any characters whatever. Most symbol names
@samp{-+=*/}. Such names require no special punctuation; the characters
of the name suffice as long as the name does not look like a number.
(If it does, write a @samp{\} at the beginning of the name to force
-interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}} are
+interpretation as a symbol.) The characters @samp{_~!@@$%^&:<>@{@}?} are
less often used but also require no special punctuation. Any other
characters may be included in a symbol's name by escaping them with a
backslash. In contrast to its use in strings, however, a backslash in
@end group
@end example
+@cindex @samp{#:} read syntax
+ Normally the Lisp reader interns all symbols (@pxref{Creating
+Symbols}). To prevent interning, you can write @samp{#:} before the
+name of the symbol.
+
@node Sequence Type
@subsection Sequence Types
@cindex decrement field of register
@cindex pointers
- A @dfn{cons cell} is an object that consists of two pointers or slots,
-called the @sc{car} slot and the @sc{cdr} slot. Each slot can
-@dfn{point to} or hold to any Lisp object. We also say that the ``the
-@sc{car} of this cons cell is'' whatever object its @sc{car} slot
-currently points to, and likewise for the @sc{cdr}.
+ A @dfn{cons cell} is an object that consists of two slots, called the
+@sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} or
+@dfn{refer to} any Lisp object. We also say that ``the @sc{car} of
+this cons cell is'' whatever object its @sc{car} slot currently holds,
+and likewise for the @sc{cdr}.
+
+@quotation
+A note to C programmers: in Lisp, we do not distinguish between
+``holding'' a value and ``pointing to'' the value, because pointers in
+Lisp are implicit.
+@end quotation
A @dfn{list} is a series of cons cells, linked together so that the
@sc{cdr} slot of each cons cell holds either the next cons cell or the
``decrement''; @sc{car} was an instruction to extract the contents of
the address part of a register, and @sc{cdr} an instruction to extract
the contents of the decrement. By contrast, ``cons cells'' are named
-for the function @code{cons} that creates them, which in turn is named
+for the function @code{cons} that creates them, which in turn was named
for its purpose, the construction of cells.
@cindex atom
Upon reading, each object inside the parentheses becomes an element
of the list. That is, a cons cell is made for each element. The
-@sc{car} slot of the cons cell points to the element, and its @sc{cdr}
-slot points to the next cons cell of the list, which holds the next
+@sc{car} slot of the cons cell holds the element, and its @sc{cdr}
+slot refers to the next cons cell of the list, which holds the next
element in the list. The @sc{cdr} slot of the last cons cell is set to
-point to @code{nil}.
+hold @code{nil}.
@cindex box diagrams, for lists
@cindex diagrams, boxed, for lists
@end group
@end example
- In this diagram, each box represents a slot that can point to any Lisp
-object. Each pair of boxes represents a cons cell. Each arrow is a
-pointer to a Lisp object, either an atom or another cons cell.
+ In this diagram, each box represents a slot that can hold or refer to
+any Lisp object. Each pair of boxes represents a cons cell. Each arrow
+represents a reference to a Lisp object, either an atom or another cons
+cell.
In this example, the first box, which holds the @sc{car} of the first
-cons cell, points to or ``contains'' @code{rose} (a symbol). The second
-box, holding the @sc{cdr} of the first cons cell, points to the next
+cons cell, refers to or ``holds'' @code{rose} (a symbol). The second
+box, holding the @sc{cdr} of the first cons cell, refers to the next
pair of boxes, the second cons cell. The @sc{car} of the second cons
cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
@sc{cdr} of the third (and last) cons cell is @code{nil}.
Similarly, the three-element list @code{(rose violet buttercup)}
is equivalent to @code{(rose . (violet . (buttercup)))}.
-@ifinfo
+@ifnottex
It looks like this:
@example
--> rose --> violet --> buttercup
@end group
@end example
-@end ifinfo
+@end ifnottex
@node Association List Type
@comment node-name, next, previous, up
first element, @code{rose} is the key and @code{red} is the value.
@xref{Association Lists}, for a further explanation of alists and for
-functions that work on alists.
+functions that work on alists. @xref{Hash Tables}, for another kind of
+lookup table, which is much faster for handling a large number of keys.
@node Array Type
@subsection Array Type
An @dfn{array} is composed of an arbitrary number of slots for
-pointing to other Lisp objects, arranged in a contiguous block of
+holding or referring to other Lisp objects, arranged in a contiguous block of
memory. Accessing any element of an array takes approximately the same
amount of time. In contrast, accessing an element of a list requires
time proportional to the position of the element in the list. (Elements
@end example
@node Non-ASCII in Strings
-@subsubsection Non-ASCII Characters in Strings
+@subsubsection Non-@sc{ascii} Characters in Strings
- You can include a non-@sc{ASCII} international character in a string
+ You can include a non-@sc{ascii} international character in a string
constant by writing it literally. There are two text representations
-for non-@sc{ASCII} characters in Emacs strings (and in buffers): unibyte
+for non-@sc{ascii} characters in Emacs strings (and in buffers): unibyte
and multibyte. If the string constant is read from a multibyte source,
such as a multibyte buffer or string, or a file that would be visited as
multibyte, then the character is read as a multibyte character, and that
unibyte source, then the character is read as unibyte and that makes the
string unibyte.
-@c ??? Change this?
- You can also represent a multibyte non-@sc{ASCII} character with its
-character code, using a hex escape, @samp{\x@var{nnnnnnn}}, with as many
-digits as necessary. (Multibyte non-@sc{ASCII} character codes are all
+ You can also represent a multibyte non-@sc{ascii} character with its
+character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many
+digits as necessary. (Multibyte non-@sc{ascii} character codes are all
greater than 256.) Any character which is not a valid hex digit
-terminates this construct. If the character that would follow is a hex
-digit, write @w{@samp{\ }} (backslash and space)
-to terminate the hex escape---for example,
-@w{@samp{\x8e0\ }} represents one character, @samp{a} with grave accent.
-@w{@samp{\ }} in a string constant is just like backslash-newline; it does
-not contribute any character to the string, but it does terminate the
-preceding hex escape.
+terminates this construct. If the next character in the string could be
+interpreted as a hex digit, write @w{@samp{\ }} (backslash and space) to
+terminate the hex escape---for example, @w{@samp{\x8e0\ }} represents
+one character, @samp{a} with grave accent. @w{@samp{\ }} in a string
+constant is just like backslash-newline; it does not contribute any
+character to the string, but it does terminate the preceding hex escape.
Using a multibyte hex escape forces the string to multibyte. You can
-represent a unibyte non-@sc{ASCII} character with its character code,
+represent a unibyte non-@sc{ascii} character with its character code,
which must be in the range from 128 (0200 octal) to 255 (0377 octal).
This forces a unibyte string.
However, not all of the characters you can write with backslash
escape-sequences are valid in strings. The only control characters that
-a string can hold are the @sc{ASCII} control characters. Strings do not
-distinguish case in @sc{ASCII} control characters.
+a string can hold are the @sc{ascii} control characters. Strings do not
+distinguish case in @sc{ascii} control characters.
Properly speaking, strings cannot hold meta characters; but when a
string is to be used as a key sequence, there is a special convention
-that provides a way to represent meta versions of @sc{ASCII} characters in a
+that provides a way to represent meta versions of @sc{ascii} characters in a
string. If you use the @samp{\M-} syntax to indicate a meta character
in a string constant, this sets the
@tex
-$2^{7}$
+@math{2^{7}}
@end tex
-@ifinfo
+@ifnottex
2**7
-@end ifinfo
+@end ifnottex
bit of the character in the string. If the string is used in
@code{define-key} or @code{lookup-key}, this numeric code is translated
into the equivalent meta character. @xref{Character Type}.
A @dfn{bool-vector} is a one-dimensional array of elements that
must be @code{t} or @code{nil}.
- The printed representation of a Bool-vector is like a string, except
+ The printed representation of a bool-vector is like a string, except
that it begins with @samp{#&} followed by the length. The string
constant that follows actually specifies the contents of the bool-vector
as a bitmap---each ``character'' in the string contains 8 bits, which
@result{} t
@end example
+@node Hash Table Type
+@subsection Hash Table Type
+
+ A hash table is a very fast kind of lookup table, somewhat like an
+alist in that it maps keys to corresponding values, but much faster.
+Hash tables are a new feature in Emacs 21; they have no read syntax, and
+print using hash notation. @xref{Hash Tables}.
+
+@example
+(make-hash-table)
+ @result{} #<hash-table 'eql nil 0/65 0x83af980>
+@end example
+
@node Function Type
@subsection Function Type
@subsection Autoload Type
An @dfn{autoload object} is a list whose first element is the symbol
-@code{autoload}. It is stored as the function definition of a symbol as
-a placeholder for the real definition; it says that the real definition
-is found in a file of Lisp code that should be loaded when necessary.
-The autoload object contains the name of the file, plus some other
-information about the real definition.
+@code{autoload}. It is stored as the function definition of a symbol,
+where it serves as a placeholder for the real definition. The autoload
+object says that the real definition is found in a file of Lisp code
+that should be loaded when necessary. It contains the name of the file,
+plus some other information about the real definition.
After the file has been loaded, the symbol should have a new function
definition that is not an autoload object. The new definition is then
The contents of a buffer are much like a string, but buffers are not
used like strings in Emacs Lisp, and the available operations are
different. For example, you can insert text efficiently into an
-existing buffer, whereas ``inserting'' text into a string requires
-concatenating substrings, and the result is an entirely new string
-object.
+existing buffer, altering the buffer's contents, whereas ``inserting''
+text into a string requires concatenating substrings, and the result is
+an entirely new string object.
Each buffer has a designated position called @dfn{point}
(@pxref{Positions}). At any time, one buffer is the @dfn{current
@xref{Overlays}, for how to create and use overlays.
+@node Circular Objects
+@section Read Syntax for Circular Objects
+@cindex circular structure, read syntax
+@cindex shared structure, read syntax
+@cindex @samp{#@var{n}=} read syntax
+@cindex @samp{#@var{n}#} read syntax
+
+ In Emacs 21, to represent shared or circular structure within a
+complex of Lisp objects, you can use the reader constructs
+@samp{#@var{n}=} and @samp{#@var{n}#}.
+
+ Use @code{#@var{n}=} before an object to label it for later reference;
+subsequently, you can use @code{#@var{n}#} to refer the same object in
+another place. Here, @var{n} is some integer. For example, here is how
+to make a list in which the first element recurs as the third element:
+
+@example
+(#1=(a) b #1#)
+@end example
+
+@noindent
+This differs from ordinary syntax such as this
+
+@example
+((a) b (a))
+@end example
+
+@noindent
+which would result in a list whose first and third elements
+look alike but are not the same Lisp object. This shows the difference:
+
+@example
+(prog1 nil
+ (setq x '(#1=(a) b #1#)))
+(eq (nth 0 x) (nth 2 x))
+ @result{} t
+(setq x '((a) b (a)))
+(eq (nth 0 x) (nth 2 x))
+ @result{} nil
+@end example
+
+ You can also use the same syntax to make a circular structure, which
+appears as an ``element'' within itself. Here is an example:
+
+@example
+#1=(a #1#)
+@end example
+
+@noindent
+This makes a list whose second element is the list itself.
+Here's how you can see that it really works:
+
+@example
+(prog1 nil
+ (setq x '#1=(a #1#)))
+(eq x (cadr x))
+ @result{} t
+@end example
+
+ The Lisp printer can produce this syntax to record circular and shared
+structure in a Lisp object, if you bind the variable @code{print-circle}
+to a non-@code{nil} value. @xref{Output Variables}.
+
@node Type Predicates
@section Type Predicates
@cindex predicates
((listp x)
;; If X is a list, add its elements to LIST.
(setq list (append x list)))
-@need 3000
(t
;; We handle only symbols and lists.
(error "Invalid argument %s in add-on" x))))
@item keymapp
@xref{Creating Keymaps, keymapp}.
+@item keywordp
+@xref{Constant Variables}.
+
@item listp
@xref{List-related Predicates, listp}.
This function returns a symbol naming the primitive type of
@var{object}. The value is one of the symbols @code{symbol},
@code{integer}, @code{float}, @code{string}, @code{cons}, @code{vector},
-@code{char-table}, @code{bool-vector}, @code{subr},
+@code{char-table}, @code{bool-vector}, @code{hash-table}, @code{subr},
@code{compiled-function}, @code{marker}, @code{overlay}, @code{window},
@code{buffer}, @code{frame}, @code{process}, or
@code{window-configuration}.
This function returns @code{t} if @var{object1} and @var{object2} have
equal components, @code{nil} otherwise. Whereas @code{eq} tests if its
arguments are the same object, @code{equal} looks inside nonidentical
-arguments to see if their elements are the same. So, if two objects are
-@code{eq}, they are @code{equal}, but the converse is not always true.
+arguments to see if their elements or contents are the same. So, if two
+objects are @code{eq}, they are @code{equal}, but the converse is not
+always true.
@example
@group
Comparison of strings is case-sensitive, but does not take account of
text properties---it compares only the characters in the strings.
A unibyte string never equals a multibyte string unless the
-contents are entirely @sc{ASCII} (@pxref{Text Representations}).
+contents are entirely @sc{ascii} (@pxref{Text Representations}).
@example
@group
@end group
@end example
-Two distinct buffers are never @code{equal}, even if their contents
-are the same.
+However, two distinct buffers are never considered @code{equal}, even if
+their textual contents are the same.
@end defun
- The test for equality is implemented recursively, and circular lists may
-therefore cause infinite recursion (leading to an error).
+ The test for equality is implemented recursively; for example, given
+two cons cells @var{x} and @var{y}, @code{(equal @var{x} @var{y})}
+returns @code{t} if and only if both the expressions below return
+@code{t}:
+
+@example
+(equal (car @var{x}) (car @var{y}))
+(equal (cdr @var{x}) (cdr @var{y}))
+@end example
+
+Because of this recursive method, circular lists may therefore cause
+infinite recursion (leading to an error).