@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2003
+@c Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/objects
-@node Types of Lisp Object, Numbers, Introduction, Top
+@node Lisp Data Types, Numbers, Introduction, Top
@chapter Lisp Data Types
@cindex object
@cindex Lisp object
@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}, and
-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.
In most languages, the programmer must declare the data type of each
variable, and the type is known by the compiler but not represented in
the data. Such type declarations do not exist in Emacs Lisp. A Lisp
-variable can have any type of value, and remembers the type of any value
-you store in it.
+variable can have any type of value, and it remembers whatever value
+you store in it, type and all. (Actually, a small number of Emacs
+Lisp variables can only take on values of a certain type.
+@xref{Variables with Restricted Values}.)
This chapter describes the purpose, printed representation, and read
syntax of each of the standard types in GNU Emacs Lisp. Details on how
* 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
output generated by the Lisp printer (the function @code{prin1}) for
that object. The @dfn{read syntax} of an object is the format of the
input accepted by the Lisp reader (the function @code{read}) for that
-object. Most objects have more than one possible read syntax. Some
-types of object have no read syntax; except for these cases, the printed
-representation of an object is also a read syntax for it.
+object. @xref{Read and Print}.
+
+ Most objects have more than one possible read syntax. Some types of
+object have no read syntax, since it may not make sense to enter objects
+of these types directly in a Lisp program. Except for these cases, the
+printed representation of an object is also a read syntax for it.
In other languages, an expression is text; it has no other form. In
Lisp, an expression is primarily a Lisp object and only secondarily the
@cindex hash notation
Every type has a printed representation. Some types have no read
-syntax, since it may not make sense to enter objects of these types
-directly in a Lisp program. For example, the buffer type does not have
-a read syntax. Objects of these types are printed in @dfn{hash
-notation}: the characters @samp{#<} followed by a descriptive string
-(typically the type name followed by the name of the object), and closed
-with a matching @samp{>}. Hash notation cannot be read at all, so the
-Lisp reader signals the error @code{invalid-read-syntax} whenever it
-encounters @samp{#<}.
+syntax---for example, the buffer type has none. Objects of these types
+are printed in @dfn{hash notation}: the characters @samp{#<} followed by
+a descriptive string (typically the type name followed by the name of
+the object), and closed with a matching @samp{>}. Hash notation cannot
+be read at all, so the Lisp reader signals the error
+@code{invalid-read-syntax} whenever it encounters @samp{#<}.
@kindex invalid-read-syntax
@example
part of the Lisp objects which represent the program within the Lisp
system.
+ The @samp{#@@@var{count}} construct, which skips the next @var{count}
+characters, is useful for program-generated comments containing binary
+data. The Emacs Lisp byte compiler uses this in its output files
+(@pxref{Byte Compilation}). It isn't meant for source files, however.
+
@xref{Comment Tips}, for conventions for formatting comments.
@node Programming Types
* Floating Point Type:: Numbers with fractional parts and with a large range.
* Character Type:: The representation of letters, numbers and
control characters.
+* Symbol Type:: A multi-use object that refers to a function,
+ variable, or property list, and has a unique identity.
* Sequence Type:: Both lists and arrays are classified as sequences.
-* List Type:: Lists gave Lisp its name (not to mention reputation).
+* Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
* Array Type:: Arrays include strings and vectors.
* String Type:: An (efficient) array of characters.
* Vector Type:: One-dimensional arrays.
-* Symbol Type:: A multi-use object that refers to a function,
- variable, property list, or itself.
-* Lisp Function Type:: A piece of executable code you can call from elsewhere.
-* Lisp Macro Type:: A method of expanding an expression into another
+* 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.
* Primitive Function Type:: A function written in C, callable from Lisp.
* Byte-Code Type:: A function written in Lisp, then compiled.
@node Integer Type
@subsection Integer Type
- Integers were the only kind of number in Emacs version 18. The range
-of values for integers is @minus{}8388608 to 8388607 (24 bits; i.e.,
-@ifinfo
--2**23
-@end ifinfo
+ The range of values for integers in Emacs Lisp is @minus{}268435456 to
+268435455 (29 bits; i.e.,
+@ifnottex
+-2**28
+@end ifnottex
@tex
-$-2^{23}$
+@math{-2^{28}}
@end tex
to
-@ifinfo
-2**23 - 1)
-@end ifinfo
+@ifnottex
+2**28 - 1)
+@end ifnottex
@tex
-$2^{23}-1$)
+@math{2^{28}-1})
@end tex
-on most machines, but is 25 or 26 bits on some systems. It is important
-to note that the Emacs Lisp arithmetic functions do not check for
-overflow. Thus @code{(1+ 8388607)} is @minus{}8388608 on 24-bit
-implementations.@refill
+on most machines. (Some machines may provide a wider range.) It is
+important to note that the Emacs Lisp arithmetic functions do not check
+for overflow. Thus @code{(1+ 268435455)} is @minus{}268435456 on most
+machines.
- The read syntax for numbers is a sequence of (base ten) digits with an
+ The read syntax for integers is a sequence of (base ten) digits with an
optional sign at the beginning and an optional period at the end. The
printed representation produced by the Lisp interpreter never has a
leading @samp{+} or a final @samp{.}.
@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.}
-16777217 ; @r{Also the integer 1!}
- ; @r{ (on a 24-bit or 25-bit implementation)}
+536870913 ; @r{Also the integer 1 on a 29-bit implementation.}
@end group
@end example
@node Floating Point Type
@subsection Floating Point Type
- Emacs version 19 supports floating point numbers (though there is a
-compilation option to disable them). The precise range of floating
-point numbers is machine-specific.
+ Floating point numbers are the computer equivalent of scientific
+notation. The precise number of significant figures and the range of
+possible exponents is machine-specific; Emacs always uses the C data
+type @code{double} to store the value.
The printed representation for floating point numbers requires either
a decimal point (with at least one digit following), an exponent, or
@node Character Type
@subsection Character Type
-@cindex @sc{ASCII} character codes
+@cindex @acronym{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
common to work with @emph{strings}, which are sequences composed of
characters. @xref{String Type}.
- Characters in strings, buffers, and files are currently limited to the
-range of 0 to 255---eight bits. If you store a larger integer into a
-string, buffer or file, it is truncated to that range. Characters that
-represent keyboard input have a much wider range.
+ 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
+@acronym{ASCII} codes; the rest are non-@acronym{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
The usual read syntax for alphanumeric characters is a question mark
followed by the character; thus, @samp{?A} for the character
@kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
-character @kbd{a}.
+character @kbd{a}.
For example:
@end example
You can use the same syntax for punctuation characters, but it is
-often a good idea to add a @samp{\} to prevent Lisp mode from getting
-confused. For example, @samp{?\ } is the way to write the space
-character. If the character is @samp{\}, you @emph{must} use a second
-@samp{\} to quote it: @samp{?\\}.
+often a good idea to add a @samp{\} so that the Emacs commands for
+editing Lisp code don't get confused. For example, @samp{?\(} is the
+way to write the open-paren character. If the character is @samp{\},
+you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.
@cindex whitespace
@cindex bell character
@cindex @samp{\r}
@cindex escape
@cindex @samp{\e}
- You can express the characters Control-g, backspace, tab, newline,
-vertical tab, formfeed, return, and escape as @samp{?\a}, @samp{?\b},
-@samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f}, @samp{?\r}, @samp{?\e},
-respectively. Those values are 7, 8, 9, 10, 11, 12, 13, and 27 in
-decimal. Thus,
+@cindex space
+@cindex @samp{\s}
+ You can express the characters control-g, backspace, tab, newline,
+vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
+@samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
+@samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
+Thus,
@example
-?\a @result{} 7 ; @r{@kbd{C-g}}
+?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
?\b @result{} 8 ; @r{backspace, @key{BS}, @kbd{C-h}}
?\t @result{} 9 ; @r{tab, @key{TAB}, @kbd{C-i}}
-?\n @result{} 10 ; @r{newline, @key{LFD}, @kbd{C-j}}
+?\n @result{} 10 ; @r{newline, @kbd{C-j}}
?\v @result{} 11 ; @r{vertical tab, @kbd{C-k}}
?\f @result{} 12 ; @r{formfeed character, @kbd{C-l}}
?\r @result{} 13 ; @r{carriage return, @key{RET}, @kbd{C-m}}
?\e @result{} 27 ; @r{escape character, @key{ESC}, @kbd{C-[}}
+?\s @result{} 32 ; @r{space character, @key{SPC}}
?\\ @result{} 92 ; @r{backslash character, @kbd{\}}
+?\d @result{} 127 ; @r{delete character, @key{DEL}}
@end example
@cindex escape sequence
These sequences which start with backslash are also known as
-@dfn{escape sequences}, because backslash plays the role of an escape
-character; this usage has nothing to do with the character @key{ESC}.
+@dfn{escape sequences}, because backslash plays the role of an
+``escape character''; this terminology has nothing to do with the
+character @key{ESC}. @samp{\s} is meant for use only in character
+constants; in string constants, just write the space.
@cindex control characters
Control characters may be represented using yet another read syntax.
?\^I @result{} 9 ?\C-I @result{} 9
@end example
- For use in strings and buffers, you are limited to the control
-characters 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
-2**22 bit as well as the code for the corresponding non-control
-character. Ordinary terminals have no way of generating non-@sc{ASCII}
-control characters, but you can generate them straightforwardly using an
-X terminal.
+ In strings and buffers, the only control characters allowed are those
+that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
+any character into a control character with @samp{C-}. The character
+codes for these non-@acronym{ASCII} control characters include the
+@tex
+@math{2^{26}}
+@end tex
+@ifnottex
+2**26
+@end ifnottex
+bit as well as the code for the corresponding non-control
+character. Ordinary terminals have no way of generating non-@acronym{ASCII}
+control characters, but you can generate them straightforwardly using X
+and other window systems.
- You can think of the @key{DEL} character as @kbd{Control-?}:
+ For historical reasons, Emacs treats the @key{DEL} character as
+the control equivalent of @kbd{?}:
@example
?\^? @result{} 127 ?\C-? @result{} 127
@end example
+@noindent
+As a result, it is currently not possible to represent the character
+@kbd{Control-?}, which is a meaningful input character under X, using
+@samp{\C-}. It is not easy to change this, as various Lisp files refer
+to @key{DEL} in this way.
+
For representing control characters to be found in files or strings,
we recommend the @samp{^} syntax; for control characters in keyboard
-input, we prefer the @samp{C-} syntax. This does not affect the meaning
-of the program, but may guide the understanding of people who read it.
+input, we prefer the @samp{C-} syntax. Which one you use does not
+affect the meaning of the program, but may guide the understanding of
+people who read it.
@cindex meta characters
A @dfn{meta character} is a character typed with the @key{META}
modifier key. The integer that represents such a character has the
-2**23 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.
+@tex
+@math{2^{27}}
+@end tex
+@ifnottex
+2**27
+@end ifnottex
+bit set. We use high bits for this and other modifiers to make
+possible a wide range of basic character codes.
- In a string, the 2**7 bit indicates a meta character, so 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} characters.
-(In Emacs versions 18 and older, this convention was used for characters
-outside of strings as well.)
+ In a string, the
+@tex
+@math{2^{7}}
+@end tex
+@ifnottex
+2**7
+@end ifnottex
+bit attached to an @acronym{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 @acronym{ASCII} characters. (In Emacs versions 18 and older,
+this convention was used for characters outside of strings as well.)
The read syntax for meta characters uses @samp{\M-}. For example,
@samp{?\M-A} stands for @kbd{M-A}. You can use @samp{\M-} together with
-octal codes, @samp{\C-}, or any other syntax for a character. Thus, you
-can write @kbd{M-A} as @samp{?\M-A}, or as @samp{?\M-\101}. Likewise,
-you can write @kbd{C-M-b} as @samp{?\M-\C-b}, @samp{?\C-\M-b}, or
-@samp{?\M-\002}.
-
- The case of an ordinary letter is indicated by its character code as
-part of @sc{ASCII}, but @sc{ASCII} has no way to represent whether a
-control character is upper case or lower case. Emacs uses the 2**21 bit
-to indicate that the shift key was used for typing a control character.
-This distinction is possible only when you use X terminals or other
-special terminals; ordinary terminals do not indicate the distinction to
-the computer in any way.
+octal character codes (see below), with @samp{\C-}, or with any other
+syntax for a character. Thus, you can write @kbd{M-A} as @samp{?\M-A},
+or as @samp{?\M-\101}. Likewise, you can write @kbd{C-M-b} as
+@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, @acronym{ASCII} distinguishes between the characters @samp{a}
+and @samp{A}. But @acronym{ASCII} has no way to represent whether a control
+character is upper case or lower case. Emacs uses the
+@tex
+@math{2^{25}}
+@end tex
+@ifnottex
+2**25
+@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. 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
@cindex alt characters
- The X Window System defines three other modifier bits that can be set
+ The X Window System defines three other @anchor{modifier bits}
+modifier bits that can be set
in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}. The syntaxes
-for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. Thus,
-@samp{?\H-\M-\A-x} represents @kbd{Alt-Hyper-Meta-x}. Numerically, the
-bit values are 2**18 for alt, 2**19 for super and 2**20 for hyper.
+for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}. (Case is
+significant in these prefixes.) Thus, @samp{?\H-\M-\A-x} represents
+@kbd{Alt-Hyper-Meta-x}. (Note that @samp{\s} with no following @samp{-}
+represents the space character.)
+@tex
+Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
+for super and @math{2^{24}} for hyper.
+@end tex
+@ifnottex
+Numerically, the
+bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
+@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
- Finally, the most general read syntax consists of a question mark
-followed by a backslash and the character code in octal (up to three
+ Finally, the most general read syntax for a character represents the
+character code in either octal or hex. To use octal, write a question
+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 @acronym{ASCII}
character, it is preferred only when the precise octal value is more
-important than the @sc{ASCII} representation.
+important than the @acronym{ASCII} representation.
@example
@group
@end group
@end example
+ To use hex, write a question mark followed by a backslash, @samp{x},
+and the hexadecimal character code. You can use any number of hex
+digits, so you can represent any character code in this way.
+Thus, @samp{?\x41} for the character @kbd{A}, @samp{?\x1} for the
+character @kbd{C-a}, and @code{?\x8e0} for the Latin-1 character
+@iftex
+@samp{@`a}.
+@end iftex
+@ifnottex
+@samp{a} with grave accent.
+@end ifnottex
+
A backslash is allowed, and harmless, preceding any character without
a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
There is no reason to add a backslash before most characters. However,
you should add a backslash before any of the characters
@samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
-Lisp code. Also add a backslash before whitespace characters such as
+Lisp code. You can also add a backslash before whitespace characters such as
space, tab, newline and formfeed. However, it is cleaner to use one of
-the easily readable escape sequences, such as @samp{\t}, instead of an
-actual whitespace character such as a tab.
+the easily readable escape sequences, such as @samp{\t} or @samp{\s},
+instead of an actual whitespace character such as a tab or a space.
+(If you do write backslash followed by a space, you should write
+an extra space after the character constant to separate it from the
+following text.)
+
+@node Symbol Type
+@subsection Symbol Type
+
+ A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The symbol
+name serves as the printed representation of the symbol. In ordinary
+use, the name is unique---no two symbols have the same name.
+
+ A symbol can serve as a variable, as a function name, or to hold a
+property list. Or it may serve only to be distinct from all other Lisp
+objects, so that its presence in a data structure may be recognized
+reliably. In a given context, usually only one of these uses is
+intended. But you can use one symbol in all of these ways,
+independently.
+
+ A symbol 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
+are written with letters, digits, and the punctuation characters
+@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
+less often used but also require no special punctuation. Any other
+characters may be included in a symbol's name by escaping them with a
+backslash. In contrast to its use in strings, however, a backslash in
+the name of a symbol simply quotes the single character that follows the
+backslash. For example, in a string, @samp{\t} represents a tab
+character; in the name of a symbol, however, @samp{\t} merely quotes the
+letter @samp{t}. To have a symbol with a tab character in its name, you
+must actually use a tab (preceded with a backslash). But it's rare to
+do such a thing.
+
+@cindex CL note---case of letters
+@quotation
+@b{Common Lisp note:} In Common Lisp, lower case letters are always
+``folded'' to upper case, unless they are explicitly escaped. In Emacs
+Lisp, upper case and lower case letters are distinct.
+@end quotation
+
+ Here are several examples of symbol names. Note that the @samp{+} in
+the fifth example is escaped to prevent it from being read as a number.
+This is not necessary in the seventh example because the rest of the name
+makes it invalid as a number.
+
+@example
+@group
+foo ; @r{A symbol named @samp{foo}.}
+FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
+char-to-string ; @r{A symbol named @samp{char-to-string}.}
+@end group
+@group
+1+ ; @r{A symbol named @samp{1+}}
+ ; @r{(not @samp{+1}, which is an integer).}
+@end group
+@group
+\+1 ; @r{A symbol named @samp{+1}}
+ ; @r{(not a very readable name).}
+@end group
+@group
+\(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
+@c the @'s in this next line use up three characters, hence the
+@c apparent misalignment of the comment.
++-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
+ ; @r{These characters need not be escaped.}
+@end group
+@end example
+
+@ifinfo
+@c This uses ``colon'' instead of a literal `:' because Info cannot
+@c cope with a `:' in a menu
+@cindex @samp{#@var{colon}} read syntax
+@end ifinfo
+@ifnotinfo
+@cindex @samp{#:} read syntax
+@end ifnotinfo
+ 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
arrays. Thus, an object of type list or of type array is also
considered a sequence.
- Arrays are further subdivided into strings and vectors. Vectors can
-hold elements of any type, but string elements must be characters in the
-range from 0 to 255. However, the characters in a string can have text
-properties; vectors do not support text properties even when their
-elements happen to be characters.
-
- Lists, strings and vectors are different, but they have important
-similarities. For example, all have a length @var{l}, and all have
-elements which can be indexed from zero to @var{l} minus one. Also,
-several functions, called sequence functions, accept any kind of
+ Arrays are further subdivided into strings, vectors, char-tables and
+bool-vectors. Vectors can hold elements of any type, but string
+elements must be characters, and bool-vector elements must be @code{t}
+or @code{nil}. Char-tables are like vectors except that they are
+indexed by any valid character code. The characters in a string can
+have text properties like characters in a buffer (@pxref{Text
+Properties}), but vectors do not support text properties, even when
+their elements happen to be characters.
+
+ Lists, strings and the other array types are different, but they have
+important similarities. For example, all have a length @var{l}, and all
+have elements which can be indexed from zero to @var{l} minus one.
+Several functions, called sequence functions, accept any kind of
sequence. For example, the function @code{elt} can be used to extract
an element of a sequence, given its index. @xref{Sequences Arrays
Vectors}.
- It is impossible to read the same sequence twice, since sequences are
-always created anew upon reading. If you read the read syntax for a
-sequence twice, you get two sequences with equal contents. There is one
-exception: the empty list @code{()} always stands for the same object,
-@code{nil}.
+ It is generally impossible to read the same sequence twice, since
+sequences are always created anew upon reading. If you read the read
+syntax for a sequence twice, you get two sequences with equal contents.
+There is one exception: the empty list @code{()} always stands for the
+same object, @code{nil}.
-@node List Type
-@subsection List Type
+@node Cons Cell Type
+@subsection Cons Cell and List Types
@cindex address field of register
@cindex decrement field of register
+@cindex pointers
+
+ 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}.
- A @dfn{list} is a series of cons cells, linked together. A @dfn{cons
-cell} is an object comprising two pointers named the @sc{car} and the
-@sc{cdr}. Each of them can point to any Lisp object, but when the cons
-cell is part of a list, the @sc{cdr} points either to another cons cell
-or to the empty list. @xref{Lists}, for functions that work on lists.
+@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
- The names @sc{car} and @sc{cdr} have only historical meaning now. The
+ 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
+empty list. @xref{Lists}, for functions that work on lists. Because
+most cons cells are used as part of lists, the phrase @dfn{list
+structure} has come to refer to any structure made out of cons cells.
+
+ The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
original Lisp implementation ran on an @w{IBM 704} computer which
divided words into two parts, called the ``address'' part and 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} of the cons cell points to the element, and its @sc{cdr} points
-to the next cons cell which holds the next element in the list. The
-@sc{cdr} of the last cons cell is set to point to @code{nil}.
+@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
+hold @code{nil}.
@cindex box diagrams, for lists
@cindex diagrams, boxed, for lists
A list can be illustrated by a diagram in which the cons cells are
-shown as pairs of boxes. (The Lisp reader cannot read such an
-illustration; unlike the textual notation, which can be understood both
-humans and computers, the box illustrations can only be understood by
-humans.) The following represents the three-element list @code{(rose
-violet buttercup)}:
+shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
+such an illustration; unlike the textual notation, which can be
+understood by both humans and computers, the box illustrations can be
+understood only by humans.) This picture represents the three-element
+list @code{(rose violet buttercup)}:
@example
@group
- ___ ___ ___ ___ ___ ___
- |___|___|--> |___|___|--> |___|___|--> nil
+ --- --- --- --- --- ---
+ | | |--> | | |--> | | |--> nil
+ --- --- --- --- --- ---
| | |
| | |
--> rose --> violet --> buttercup
@end group
@end example
- In this diagram, each box represents a slot that can refer to any Lisp
-object. Each pair of boxes represents a cons cell. Each arrow is a
-reference to a Lisp object, either an atom or another cons cell.
+ In this 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, the @sc{car} of the first cons cell,
-refers to or ``contains'' @code{rose} (a symbol). The second box, 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 refers to
-@code{violet} and the @sc{cdr} refers to the third cons cell. The
-@sc{cdr} of the third (and last) cons cell refers to @code{nil}.
+ In this example, the first box, which holds the @sc{car} of the first
+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}.
-Here is another diagram of the same list, @code{(rose violet
+ Here is another diagram of the same list, @code{(rose violet
buttercup)}, sketched in a different manner:
@smallexample
@example
@group
- ___ ___ ___ ___
- |___|___|--> |___|___|--> nil
+ --- --- --- ---
+ | | |--> | | |--> nil
+ --- --- --- ---
| |
| |
--> A --> nil
@code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
the object @var{a}, and whose @sc{cdr} is the object @var{b}. Dotted
pair notation is therefore more general than list syntax. In the dotted
-pair notation, the list @samp{(1 2 3)} is written as @samp{(1 . (2 . (3
-. nil)))}. For @code{nil}-terminated lists, the two notations produce
-the same result, but list notation is usually clearer and more
-convenient when it is applicable. When printing a list, the dotted pair
-notation is only used if the @sc{cdr} of a cell is not a list.
+pair notation, the list @samp{(1 2 3)} is written as @samp{(1 . (2 . (3
+. nil)))}. For @code{nil}-terminated lists, you can use either
+notation, but list notation is usually clearer and more convenient.
+When printing a list, the dotted pair notation is only used if the
+@sc{cdr} of a cons cell is not a list.
- Here's how box notation can illustrate dotted pairs. This example
-shows the pair @code{(rose . violet)}:
+ Here's an example using boxes to illustrate dotted pair notation.
+This example shows the pair @code{(rose . violet)}:
@example
@group
- ___ ___
- |___|___|--> violet
+ --- ---
+ | | |--> violet
+ --- ---
|
|
--> rose
@end group
@end example
- Dotted pair notation can be combined with list notation to represent a
-chain of cons cells with a non-@code{nil} final @sc{cdr}. For example,
-@code{(rose violet . buttercup)} is equivalent to @code{(rose . (violet
-. buttercup))}. The object looks like this:
+ You can combine dotted pair notation with list notation to represent
+conveniently a chain of cons cells with a non-@code{nil} final @sc{cdr}.
+You write a dot after the last element of the list, followed by the
+@sc{cdr} of the final cons cell. For example, @code{(rose violet
+. buttercup)} is equivalent to @code{(rose . (violet . buttercup))}.
+The object looks like this:
@example
@group
- ___ ___ ___ ___
- |___|___|--> |___|___|--> buttercup
+ --- --- --- ---
+ | | |--> | | |--> buttercup
+ --- --- --- ---
| |
| |
--> rose --> violet
@end group
@end example
- These diagrams make it evident why @w{@code{(rose .@: violet .@:
-buttercup)}} is invalid syntax; it would require a cons cell that has
-three parts rather than two.
+ The syntax @code{(rose .@: violet .@: buttercup)} is invalid because
+there is nothing that it could mean. If anything, it would say to put
+@code{buttercup} in the @sc{cdr} of a cons cell whose @sc{cdr} is already
+used for @code{violet}.
- The list @code{(rose violet)} is equivalent to @code{(rose . (violet))}
+ The list @code{(rose violet)} is equivalent to @code{(rose . (violet))},
and looks like this:
@example
@group
- ___ ___ ___ ___
- |___|___|--> |___|___|--> nil
+ --- --- --- ---
+ | | |--> | | |--> nil
+ --- --- --- ---
| |
| |
--> rose --> violet
Similarly, the three-element list @code{(rose violet buttercup)}
is equivalent to @code{(rose . (violet . (buttercup)))}.
-@ifinfo
+@ifnottex
It looks like this:
@example
@group
- ___ ___ ___ ___ ___ ___
- |___|___|--> |___|___|--> |___|___|--> nil
+ --- --- --- --- --- ---
+ | | |--> | | |--> | | |--> nil
+ --- --- --- --- --- ---
| | |
| | |
--> rose --> violet --> buttercup
@end group
@end example
-@end ifinfo
+@end ifnottex
@node Association List Type
@comment node-name, next, previous, up
@example
(setq alist-of-colors
- '((rose . red) (lily . white) (buttercup . yellow)))
+ '((rose . red) (lily . white) (buttercup . yellow)))
@end example
@noindent
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
-referring to other Lisp objects, arranged in a contiguous block of
-memory. Accessing any element of an array takes a the same amount of
-time. In contrast, accessing an element of a list requires time
-proportional to the position of the element in the list. (Elements at
-the end of a list take longer to access than elements at the beginning
-of a list.)
-
- Emacs defines two types of array, strings and vectors. A string is an
-array of characters and a vector is an array of arbitrary objects. Both
-are one-dimensional. (Most other programming languages support
-multidimensional arrays, but they are not essential; you can get the
-same effect with an array of arrays.) Each type of array has its own
-read syntax; see @ref{String Type}, and @ref{Vector Type}.
-
- An array may have any length up to the largest integer; but once
-created, it has a fixed size. The first element of an array has index
-zero, the second element has index 1, and so on. This is called
-@dfn{zero-origin} indexing. For example, an array of four elements has
-indices 0, 1, 2, @w{and 3}.
-
- The array type is contained in the sequence type and contains both the
-string type and the vector type.
+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
+at the end of a list take longer to access than elements at the
+beginning of a list.)
+
+ Emacs defines four types of array: strings, vectors, bool-vectors, and
+char-tables.
+
+ A string is an array of characters and a vector is an array of
+arbitrary objects. A bool-vector can hold only @code{t} or @code{nil}.
+These kinds of array may have any length up to the largest integer.
+Char-tables are sparse arrays indexed by any valid character code; they
+can hold arbitrary objects.
+
+ The first element of an array has index zero, the second element has
+index 1, and so on. This is called @dfn{zero-origin} indexing. For
+example, an array of four elements has indices 0, 1, 2, @w{and 3}. The
+largest possible index value is one less than the length of the array.
+Once an array is created, its length is fixed.
+
+ All Emacs Lisp arrays are one-dimensional. (Most other programming
+languages support multidimensional arrays, but they are not essential;
+you can get the same effect with an array of arrays.) Each type of
+array has its own read syntax; see the following sections for details.
+
+ The array type is contained in the sequence type and
+contains the string type, the vector type, the bool-vector type, and the
+char-table type.
@node String Type
@subsection String Type
text extracted from buffers. Strings in Lisp are constants: evaluation
of a string returns the same string.
+ @xref{Strings and Characters}, for functions that operate on strings.
+
+@menu
+* Syntax for Strings::
+* Non-ASCII in Strings::
+* Nonprinting Characters::
+* Text Props and Strings::
+@end menu
+
+@node Syntax for Strings
+@subsubsection Syntax for Strings
+
@cindex @samp{"} in strings
@cindex double-quote in strings
@cindex @samp{\} in strings
@cindex backslash in strings
The read syntax for strings is a double-quote, an arbitrary number of
-characters, and another double-quote, @code{"like this"}. The Lisp
-reader accepts the same formats for reading the characters of a string
-as it does for reading single characters (without the question mark that
-begins a character literal). You can enter a nonprinting character such
-as tab, @kbd{C-a} or @kbd{M-C-A} using the convenient escape sequences,
-like this: @code{"\t, \C-a, \M-\C-a"}. You can include a double-quote
-in a string by preceding it with a backslash; thus, @code{"\""} is a
-string containing just a single double-quote character.
-(@xref{Character Type}, for a description of the read syntax for
-characters.)
-
- If you use the @samp{\M-} syntax to indicate a meta character in a
-string constant, this sets the 2**7 bit of the character in the string.
-This is not the same representation that the meta modifier has in a
-character on its own (not inside a string). @xref{Character Type}.
-
- Strings cannot hold characters that have the hyper, super or alt
-modifiers; they can hold @sc{ASCII} control characters, but no others.
-They do not distinguish case in @sc{ASCII} control characters.
-
- In contrast with the C programming language, Emacs Lisp allows
-newlines in string literals. But an escaped newline---one that is
-preceded by @samp{\}---does not become part of the string; i.e., the
-Lisp reader ignores an escaped newline in a string literal.
+characters, and another double-quote, @code{"like this"}. To include a
+double-quote in a string, precede it with a backslash; thus, @code{"\""}
+is a string containing just a single double-quote character. Likewise,
+you can include a backslash by preceding it with another backslash, like
+this: @code{"this \\ is a single embedded backslash"}.
+
@cindex newline in strings
+ The newline character is not special in the read syntax for strings;
+if you write a new line between the double-quotes, it becomes a
+character in the string. But an escaped newline---one that is preceded
+by @samp{\}---does not become part of the string; i.e., the Lisp reader
+ignores an escaped newline while reading a string. An escaped space
+@w{@samp{\ }} is likewise ignored.
@example
"It is useful to include newlines
in documentation strings,
but the newline is \
ignored if escaped."
- @result{} "It is useful to include newlines
-in documentation strings,
+ @result{} "It is useful to include newlines
+in documentation strings,
but the newline is ignored if escaped."
@end example
- The printed representation of a string consists of a double-quote, the
-characters it contains, and another double-quote. However, any
-backslash or double-quote characters in the string are preceded with a
-backslash like this: @code{"this \" is an embedded quote"}.
-
- A string can hold properties of the text it contains, in addition to
-the characters themselves. This enables programs that copy text between
-strings and buffers to preserve the properties with no special effort.
-@xref{Text Properties}. Strings with text properties have a special
-read and print syntax:
+@node Non-ASCII in Strings
+@subsubsection Non-@acronym{ASCII} Characters in Strings
+
+ You can include a non-@acronym{ASCII} international character in a string
+constant by writing it literally. There are two text representations
+for non-@acronym{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
+makes the string multibyte. If the string constant is read from a
+unibyte source, then the character is read as unibyte and that makes the
+string unibyte.
+
+ You can also represent a multibyte non-@acronym{ASCII} character with its
+character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many
+digits as necessary. (Multibyte non-@acronym{ASCII} character codes are all
+greater than 256.) Any character which is not a valid hex digit
+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.
+
+ You can represent a unibyte non-@acronym{ASCII} character with its
+character code, which must be in the range from 128 (0200 octal) to
+255 (0377 octal). If you write all such character codes in octal and
+the string contains no other characters forcing it to be multibyte,
+this produces a unibyte string. However, using any hex escape in a
+string (even for an @acronym{ASCII} character) forces the string to be
+multibyte.
+
+ @xref{Text Representations}, for more information about the two
+text representations.
+
+@node Nonprinting Characters
+@subsubsection Nonprinting Characters in Strings
+
+ You can use the same backslash escape-sequences in a string constant
+as in character literals (but do not use the question mark that begins a
+character constant). For example, you can write a string containing the
+nonprinting characters tab and @kbd{C-a}, with commas and spaces between
+them, like this: @code{"\t, \C-a"}. @xref{Character Type}, for a
+description of the read syntax for characters.
+
+ 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 @acronym{ASCII} control characters. Strings do not
+distinguish case in @acronym{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 @acronym{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
+@math{2^{7}}
+@end tex
+@ifnottex
+2**7
+@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}.
+
+ Strings cannot hold characters that have the hyper, super, or alt
+modifiers.
+
+@node Text Props and Strings
+@subsubsection Text Properties in Strings
+
+ A string can hold properties for the characters it contains, in
+addition to the characters themselves. This enables programs that copy
+text between strings and buffers to copy the text's properties with no
+special effort. @xref{Text Properties}, for an explanation of what text
+properties mean. Strings with text properties use a special read and
+print syntax:
@example
#("@var{characters}" @var{property-data}...)
@noindent
The elements @var{beg} and @var{end} are integers, and together specify
a range of indices in the string; @var{plist} is the property list for
-that range.
+that range. For example,
- @xref{Strings and Characters}, for functions that work on strings.
+@example
+#("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))
+@end example
+
+@noindent
+represents a string whose textual contents are @samp{foo bar}, in which
+the first three characters have a @code{face} property with value
+@code{bold}, and the last three have a @code{face} property with value
+@code{italic}. (The fourth character has no text properties, so its
+property list is @code{nil}. It is not actually necessary to mention
+ranges with @code{nil} as the property list, since any characters not
+mentioned in any range will default to having no properties.)
@node Vector Type
@subsection Vector Type
@xref{Vectors}, for functions that work with vectors.
-@node Symbol Type
-@subsection Symbol Type
+@node Char-Table Type
+@subsection Char-Table Type
- A @dfn{symbol} in GNU Emacs Lisp is an object with a name. The symbol
-name serves as the printed representation of the symbol. In ordinary
-use, the name is unique---no two symbols have the same name.
+ A @dfn{char-table} is a one-dimensional array of elements of any type,
+indexed by character codes. Char-tables have certain extra features to
+make them more useful for many jobs that involve assigning information
+to character codes---for example, a char-table can have a parent to
+inherit from, a default value, and a small number of extra slots to use for
+special purposes. A char-table can also specify a single value for
+a whole character set.
- A symbol can serve as a variable, as a function name, or to hold a
-property list. Or it may serve only to be distinct from all other Lisp
-objects, so that its presence in a data structure may be recognized
-reliably. In a given context, usually only one of these uses is
-intended. But you can use one symbol in all of these ways,
-independently.
+ The printed representation of a char-table is like a vector
+except that there is an extra @samp{#^} at the beginning.
-@cindex @samp{\} in symbols
-@cindex backslash in symbols
- A symbol name can contain any characters whatever. Most symbol names
-are written with letters, digits, and the punctuation characters
-@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
-less often used but also require no special punctuation. Any other
-characters may be included in a symbol's name by escaping them with a
-backslash. In contrast to its use in strings, however, a backslash in
-the name of a symbol quotes the single character that follows the
-backslash, without conversion. For example, in a string, @samp{\t}
-represents a tab character; in the name of a symbol, however, @samp{\t}
-merely quotes the letter @kbd{t}. To have a symbol with a tab character
-in its name, you must actually use a tab (preceded with a backslash).
-But it's rare to do such a thing.
+ @xref{Char-Tables}, for special functions to operate on char-tables.
+Uses of char-tables include:
-@cindex CL note---case of letters
-@quotation
-@b{Common Lisp note:} in Common Lisp, lower case letters are always
-``folded'' to upper case, unless they are explicitly escaped. This is
-in contrast to Emacs Lisp, in which upper case and lower case letters
-are distinct.
-@end quotation
+@itemize @bullet
+@item
+Case tables (@pxref{Case Tables}).
- Here are several examples of symbol names. Note that the @samp{+} in
-the fifth example is escaped to prevent it from being read as a number.
-This is not necessary in the last example because the rest of the name
-makes it invalid as a number.
+@item
+Character category tables (@pxref{Categories}).
+
+@item
+Display tables (@pxref{Display Tables}).
+
+@item
+Syntax tables (@pxref{Syntax Tables}).
+@end itemize
+
+@node Bool-Vector Type
+@subsection Bool-Vector 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
+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
+specify the next 8 elements of the bool-vector (1 stands for @code{t},
+and 0 for @code{nil}). The least significant bits of the character
+correspond to the lowest indices in the bool-vector.
@example
-@group
-foo ; @r{A symbol named @samp{foo}.}
-FOO ; @r{A symbol named @samp{FOO}, different from @samp{foo}.}
-char-to-string ; @r{A symbol named @samp{char-to-string}.}
-@end group
-@group
-1+ ; @r{A symbol named @samp{1+}}
- ; @r{(not @samp{+1}, which is an integer).}
-@end group
-@group
-\+1 ; @r{A symbol named @samp{+1}}
- ; @r{(not a very readable name).}
-@end group
-@group
-\(*\ 1\ 2\) ; @r{A symbol named @samp{(* 1 2)} (a worse name).}
-@c the @'s in this next line use up three characters, hence the
-@c apparent misalignment of the comment.
-+-*/_~!@@$%^&=:<>@{@} ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
- ; @r{These characters need not be escaped.}
-@end group
+(make-bool-vector 3 t)
+ @result{} #&3"^G"
+(make-bool-vector 3 nil)
+ @result{} #&3"^@@"
+@end example
+
+@noindent
+These results make sense, because the binary code for @samp{C-g} is
+111 and @samp{C-@@} is the character with code 0.
+
+ If the length is not a multiple of 8, the printed representation
+shows extra elements, but these extras really make no difference. For
+instance, in the next example, the two bool-vectors are equal, because
+only the first 3 bits are used:
+
+@example
+(equal #&3"\377" #&3"\007")
+ @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 Lisp Function Type
-@subsection Lisp Function Type
+@node Function Type
+@subsection Function Type
Just as functions in other programming languages are executable,
@dfn{Lisp function} objects are pieces of executable code. However,
a function object at run time and then call it with the primitive
functions @code{funcall} and @code{apply}. @xref{Calling Functions}.
-@node Lisp Macro Type
-@subsection Lisp Macro Type
+@node Macro Type
+@subsection Macro Type
A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
language. It is represented as an object much like a function, but with
-different parameter-passing semantics. A Lisp macro has the form of a
+different argument-passing semantics. A Lisp macro has the form of a
list whose first element is the symbol @code{macro} and whose @sc{cdr}
is a Lisp function object, including the @code{lambda} symbol.
a macro as far as Emacs is concerned. @xref{Macros}, for an explanation
of how to write a macro.
+ @strong{Warning}: Lisp macros and keyboard macros (@pxref{Keyboard
+Macros}) are entirely different things. When we use the word ``macro''
+without qualification, we mean a Lisp macro, not a keyboard macro.
+
@node Primitive Function Type
@subsection Primitive Function Type
@cindex special forms
(@pxref{Special Forms}).@refill
It does not matter to the caller of a function whether the function is
-primitive. However, this does matter if you try to substitute a
-function written in Lisp for a primitive of the same name. The reason
-is that the primitive function may be called directly from C code.
-Calls to the redefined function from Lisp will use the new definition,
-but calls from C code may still use the built-in definition.
+primitive. However, this does matter if you try to redefine a primitive
+with a function written in Lisp. The reason is that the primitive
+function may be called directly from C code. Calls to the redefined
+function from Lisp will use the new definition, but calls from C code
+may still use the built-in definition. Therefore, @strong{we discourage
+redefinition of primitive functions}.
The term @dfn{function} refers to all Emacs functions, whether written
-in Lisp or C. @xref{Lisp Function Type}, for information about the
-functions written in Lisp.@refill
+in Lisp or C. @xref{Function Type}, for information about the
+functions written in Lisp.
Primitive functions have no read syntax and print in hash notation
with the name of the subroutine.
function to be called. @xref{Byte Compilation}, for information about
the byte compiler.
-The printed representation for a byte-code function object is like that
-for a vector, with an additional @samp{#} before the opening @samp{[}.
+The printed representation and read syntax for a byte-code function
+object is like that for a vector, with an additional @samp{#} before the
+opening @samp{[}.
@node Autoload 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
@section Editing Types
@cindex editing types
- The types in the previous section are common to many Lisp dialects.
-Emacs Lisp provides several additional data types for purposes connected
-with editing.
+ The types in the previous section are used for general programming
+purposes, and most of them are common to most Lisp dialects. Emacs Lisp
+provides several additional data types for purposes connected with
+editing.
@menu
* Buffer Type:: The basic object of editing.
* Window Type:: Buffers are displayed in windows.
* Frame Type:: Windows subdivide frames.
* Window Configuration Type:: Recording the way a frame is subdivided.
+* Frame Configuration Type:: Recording the status of all frames.
* Process Type:: A process running on the underlying OS.
* Stream Type:: Receive or send characters.
* Keymap Type:: What function a keystroke invokes.
-* Syntax Table Type:: What a character means.
-* Display Table Type:: How display tables are represented.
* Overlay Type:: How an overlay is represented.
@end menu
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, insertion of text into a buffer is very
-efficient, whereas ``inserting'' text into a string requires
-concatenating substrings, and the result is an entirely new string
-object.
+different. For example, you can insert text efficiently into an
+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
buffer}. Most editing commands act on the contents of the current
-buffer in the neighborhood of point. Many other functions manipulate or
-test the characters in the current buffer; a whole chapter in this
-manual is devoted to describing these functions (@pxref{Text}).
+buffer in the neighborhood of point. Many of the standard Emacs
+functions manipulate or test the characters in the current buffer; a
+whole chapter in this manual is devoted to describing these functions
+(@pxref{Text}).
Several other data structures are associated with each buffer:
a local keymap (@pxref{Keymaps}); and,
@item
-a local variable binding list (@pxref{Buffer-Local Variables}).
+a list of buffer-local variable bindings (@pxref{Buffer-Local Variables}).
+
+@item
+overlays (@pxref{Overlays}).
+
+@item
+text properties for the text in the buffer (@pxref{Text Properties}).
@end itemize
@noindent
-The local keymap and variable list contain entries which individually
+The local keymap and variable list contain entries that individually
override global bindings or values. These are used to customize the
behavior of programs in different buffers, without actually changing the
programs.
- Buffers have no read syntax. They print in hash notation with the
+ A buffer may be @dfn{indirect}, which means it shares the text
+of another buffer, but presents it differently. @xref{Indirect Buffers}.
+
+ Buffers have no read syntax. They print in hash notation, showing the
buffer name.
@example
@node Frame Type
@subsection Frame Type
- A @var{frame} is a rectangle on the screen that contains one or more
+ A @dfn{frame} is a rectangle on the screen that contains one or more
Emacs windows. A frame initially contains a single main window (plus
perhaps a minibuffer window) which you can subdivide vertically or
horizontally into smaller windows.
@example
@group
(selected-frame)
- @result{} #<frame xemacs@@mole.gnu.ai.mit.edu 0xdac80>
+ @result{} #<frame emacs@@psilocin.gnu.org 0xdac80>
@end group
@end example
sizes, and contents of the windows in a frame, so you can recreate the
same arrangement of windows later.
- Window configurations do not have a read syntax. They print as
-@samp{#<window-configuration>}. @xref{Window Configurations}, for a
-description of several functions related to window configurations.
+ Window configurations do not have a read syntax; their print syntax
+looks like @samp{#<window-configuration>}. @xref{Window
+Configurations}, for a description of several functions related to
+window configurations.
+
+@node Frame Configuration Type
+@subsection Frame Configuration Type
+@cindex screen layout
+
+ A @dfn{frame configuration} stores information about the positions,
+sizes, and contents of the windows in all frames. It is actually
+a list whose @sc{car} is @code{frame-configuration} and whose
+@sc{cdr} is an alist. Each alist element describes one frame,
+which appears as the @sc{car} of that element.
+
+ @xref{Frame Configurations}, for a description of several functions
+related to frame configurations.
@node Process Type
@subsection Process Type
Streams have no special printed representation or read syntax, and
print as whatever primitive type they are.
- @xref{Streams}, for a description of various functions related to
-streams, including various parsing and printing functions.
+ @xref{Read and Print}, for a description of functions
+related to streams, including parsing and printing functions.
@node Keymap Type
@subsection Keymap Type
@xref{Keymaps}, for information about creating keymaps, handling prefix
keys, local as well as global keymaps, and changing key bindings.
-@node Syntax Table Type
-@subsection Syntax Table Type
+@node Overlay Type
+@subsection Overlay Type
- A @dfn{syntax table} is a vector of 256 integers. Each element of the
-vector defines how one character is interpreted when it appears in a
-buffer. For example, in C mode (@pxref{Major Modes}), the @samp{+}
-character is punctuation, but in Lisp mode it is a valid character in a
-symbol. These modes specify different interpretations by changing the
-syntax table entry for @samp{+}, at index 43 in the syntax table.
+ An @dfn{overlay} specifies properties that apply to a part of a
+buffer. Each overlay applies to a specified range of the buffer, and
+contains a property list (a list whose elements are alternating property
+names and values). Overlay properties are used to present parts of the
+buffer temporarily in a different display style. Overlays have no read
+syntax, and print in hash notation, giving the buffer name and range of
+positions.
- Syntax tables are only used for scanning text in buffers, not for
-reading Lisp expressions. The table the Lisp interpreter uses to read
-expressions is built into the Emacs source code and cannot be changed;
-thus, to change the list delimiters to be @samp{@{} and @samp{@}}
-instead of @samp{(} and @samp{)} would be impossible.
+ @xref{Overlays}, for how to create and use overlays.
- @xref{Syntax Tables}, for details about syntax classes and how to make
-and modify syntax tables.
+@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
-@node Display Table Type
-@subsection Display Table Type
+ In Emacs 21, to represent shared or circular structures within a
+complex of Lisp objects, you can use the reader constructs
+@samp{#@var{n}=} and @samp{#@var{n}#}.
- A @dfn{display table} specifies how to display each character code.
-Each buffer and each window can have its own display table. A display
-table is actually a vector of length 261. @xref{Display Tables}.
+ 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:
-@node Overlay Type
-@subsection Overlay Type
+@example
+(#1=(a) b #1#)
+@end example
+
+@noindent
+This differs from ordinary syntax such as this
+
+@example
+((a) b (a))
+@end example
- An @dfn{overlay} specifies temporary alteration of the display
-appearance of a part of a buffer. It contains markers delimiting a
-range of the buffer, plus a property list (a list whose elements are
-alternating property names and values). Overlays are used to present
-parts of the buffer temporarily in a different display style.
+@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
- @xref{Overlays}, for how to create and use overlays. They have no
-read syntax, and print in hash notation, giving the buffer name and
-range of positions.
+ 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
All built-in functions do check the types of their actual arguments
when appropriate, and signal a @code{wrong-type-argument} error if an
argument is of the wrong type. For example, here is what happens if you
-pass an argument to @code{+} which it cannot handle:
+pass an argument to @code{+} that it cannot handle:
@example
@group
(+ 2 'a)
- @error{} Wrong type argument: integer-or-marker-p, a
+ @error{} Wrong type argument: number-or-marker-p, a
@end group
@end example
@cindex type predicates
@cindex testing types
- Lisp provides functions, called @dfn{type predicates}, to test whether
-an object is a member of a given type. (Following a convention of long
-standing, the names of most Emacs Lisp predicates end in @samp{p}.)
+ If you want your program to handle different types differently, you
+must do explicit type checking. The most common way to check the type
+of an object is to call a @dfn{type predicate} function. Emacs has a
+type predicate for each type, as well as some predicates for
+combinations of types.
+
+ A type predicate function takes one argument; it returns @code{t} if
+the argument belongs to the appropriate type, and @code{nil} otherwise.
+Following a general Lisp convention for predicate functions, most type
+predicates' names end with @samp{p}.
+
+ Here is an example which uses the predicates @code{listp} to check for
+a list and @code{symbolp} to check for a symbol.
+
+@example
+(defun add-on (x)
+ (cond ((symbolp x)
+ ;; If X is a symbol, put it on LIST.
+ (setq list (cons x list)))
+ ((listp x)
+ ;; If X is a list, add its elements to LIST.
+ (setq list (append x list)))
+ (t
+ ;; We handle only symbols and lists.
+ (error "Invalid argument %s in add-on" x))))
+@end example
-Here is a table of predefined type predicates, in alphabetical order,
+ Here is a table of predefined type predicates, in alphabetical order,
with references to further information.
@table @code
@item arrayp
@xref{Array Functions, arrayp}.
+@item bool-vector-p
+@xref{Bool-Vectors, bool-vector-p}.
+
@item bufferp
@xref{Buffer Basics, bufferp}.
@xref{Byte-Code Type, byte-code-function-p}.
@item case-table-p
-@xref{Case Table, case-table-p}.
+@xref{Case Tables, case-table-p}.
@item char-or-string-p
@xref{Predicates for Strings, char-or-string-p}.
+@item char-table-p
+@xref{Char-Tables, char-table-p}.
+
@item commandp
@xref{Interactive Call, commandp}.
@item consp
@xref{List-related Predicates, consp}.
+@item display-table-p
+@xref{Display Tables, display-table-p}.
+
@item floatp
@xref{Predicates on Numbers, floatp}.
+@item frame-configuration-p
+@xref{Frame Configurations, frame-configuration-p}.
+
@item frame-live-p
@xref{Deleting Frames, frame-live-p}.
@item framep
@xref{Frames, framep}.
+@item functionp
+@xref{Functions, functionp}.
+
@item integer-or-marker-p
@xref{Predicates on Markers, integer-or-marker-p}.
@item keymapp
@xref{Creating Keymaps, keymapp}.
+@item keywordp
+@xref{Constant Variables}.
+
@item listp
@xref{List-related Predicates, listp}.
@item markerp
@xref{Predicates on Markers, markerp}.
-@item natnump
-@xref{Predicates on Numbers, natnump}.
+@item wholenump
+@xref{Predicates on Numbers, wholenump}.
@item nlistp
@xref{List-related Predicates, nlistp}.
@xref{Basic Windows, windowp}.
@end table
+ The most general way to check the type of an object is to call the
+function @code{type-of}. Recall that each object belongs to one and
+only one primitive type; @code{type-of} tells you which one (@pxref{Lisp
+Data Types}). But @code{type-of} knows nothing about non-primitive
+types. In most cases, it is more convenient to use type predicates than
+@code{type-of}.
+
+@defun type-of object
+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{hash-table}, @code{subr},
+@code{compiled-function}, @code{marker}, @code{overlay}, @code{window},
+@code{buffer}, @code{frame}, @code{process}, or
+@code{window-configuration}.
+
+@example
+(type-of 1)
+ @result{} integer
+(type-of 'nil)
+ @result{} symbol
+(type-of '()) ; @r{@code{()} is @code{nil}.}
+ @result{} symbol
+(type-of '(x))
+ @result{} cons
+@end example
+@end defun
+
@node Equality Predicates
@section Equality Predicates
@cindex equality
Here we describe two functions that test for equality between any two
objects. Other functions test equality between objects of specific
-types, e.g., strings. See the appropriate chapter describing the data
-type for these predicates.
+types, e.g., strings. For these predicates, see the appropriate chapter
+describing the data type.
@defun eq object1 object2
This function returns @code{t} if @var{object1} and @var{object2} are
@code{eq} to each other: they are @code{eq} only if they are the same
object.
-(The @code{make-symbol} function returns an uninterned symbol that is
-not interned in the standard @code{obarray}. When uninterned symbols
-are in use, symbol names are no longer unique. Distinct symbols with
-the same name are not @code{eq}. @xref{Creating Symbols}.)
-
@example
@group
(eq 'foo 'foo)
@end group
@end example
+The @code{make-symbol} function returns an uninterned symbol, distinct
+from the symbol that is used if you write the name in a Lisp expression.
+Distinct symbols with the same name are not @code{eq}. @xref{Creating
+Symbols}.
+
+@example
+@group
+(eq (make-symbol "foo") 'foo)
+ @result{} nil
+@end group
+@end example
@end defun
@defun equal object1 object2
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
@end group
@end example
-Comparison of strings uses @code{string=}, and is case-sensitive.
+Comparison of strings is case-sensitive, but does not take account of
+text properties---it compares only the characters in the strings. For
+technical reasons, a unibyte string and a multibyte string are
+@code{equal} if and only if they contain the same sequence of
+character codes and all these codes are either in the range 0 through
+127 (@acronym{ASCII}) or 160 through 255 (@code{eight-bit-graphic}).
+(@pxref{Text Representations}).
@example
@group
@result{} nil
@end group
@end example
+
+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).
+
+@ignore
+ arch-tag: 9711a66e-4749-4265-9e8c-972d55b67096
+@end ignore
HCoop / bpt / emacs.git / blobdiff