@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2003
-@c Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002, 2003,
+@c 2004, 2005, 2006 Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/objects
@node Lisp Data Types, Numbers, Introduction, Top
The @dfn{printed representation} of an object is the format of the
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. @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
-text that is the object's read syntax. Often there is no need to
-emphasize this distinction, but you must keep it in the back of your
-mind, or you will occasionally be very confused.
+that object. Every data type has a unique printed representation.
+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. This
+is not necessarily unique; many kinds of object have more than one
+syntax. @xref{Read and Print}.
@cindex hash notation
- Every type has a printed representation. Some types have no read
-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
+ In most cases, an object's printed representation is also a read
+syntax for the object. However, some types have no read syntax, since
+it does not make sense to enter objects of these types as constants in
+a Lisp program. These objects are printed in @dfn{hash notation},
+which consists of the characters @samp{#<}, a descriptive string
+(typically the type name followed by the name of the object), and a
+closing @samp{>}. For example:
@example
(current-buffer)
@result{} #<buffer objects.texi>
@end example
+@noindent
+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
+
+ 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
+text that is the object's read syntax. Often there is no need to
+emphasize this distinction, but you must keep it in the back of your
+mind, or you will occasionally be very confused.
+
When you evaluate an expression interactively, the Lisp interpreter
first reads the textual representation of it, producing a Lisp object,
and then evaluates that object (@pxref{Evaluation}). However,
@subsection Floating Point Type
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.
+notation; you can think of a floating point number as a fraction
+together with a power of ten. The precise number of significant
+figures and the range of possible exponents is machine-specific; Emacs
+uses the C data type @code{double} to store the value, and internally
+this records a power of 2 rather than a power of 10.
The printed representation for floating point numbers requires either
a decimal point (with at least one digit following), an exponent, or
other words, characters are represented by their character codes. For
example, the character @kbd{A} is represented as the @w{integer 65}.
- Individual characters are not often used in programs. It is far more
-common to work with @emph{strings}, which are sequences composed of
-characters. @xref{String Type}.
+ Individual characters are used occasionally in programs, but it is
+more 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 524287---nineteen bits. But not all values in that
input have a much wider range, to encode modifier keys such as
Control, Meta and Shift.
+ There are special functions for producing a human-readable textual
+description of a character for the sake of messages. @xref{Describing
+Characters}.
+
+@menu
+* Basic Char Syntax::
+* General Escape Syntax::
+* Ctl-Char Syntax::
+* Meta-Char Syntax::
+* Other Char Bits::
+@end menu
+
+@node Basic Char Syntax
+@subsubsection Basic Char Syntax
@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
-bad idea. You should @emph{always} use the special read syntax formats
-that Emacs Lisp provides for characters. These syntax formats start
-with a question mark.
+
+ 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
+not clear programming. You should @emph{always} use the special read
+syntax formats that Emacs Lisp provides for characters. These syntax
+formats start with a question mark.
The usual read syntax for alphanumeric characters is a question mark
followed by the character; thus, @samp{?A} for the character
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,
+(@samp{?\s} followed by a dash has a different meaning---it applies
+the ``super'' modifier to the following character.) Thus,
@example
?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
These sequences which start with backslash are also known as
@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
+character @key{ESC}. @samp{\s} is meant for use in character
constants; in string constants, just write the space.
+ 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. 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} 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 General Escape Syntax
+@subsubsection General Escape Syntax
+
+ In addition to the specific excape sequences for special important
+control characters, Emacs provides general categories of escape syntax
+that you can use to specify non-ASCII text characters.
+
+@cindex unicode character escape
+ For instance, you can specify characters by their Unicode values.
+@code{?\u@var{nnnn}} represents a character that maps to the Unicode
+code point @samp{U+@var{nnnn}}. There is a slightly different syntax
+for specifying characters with code points above @code{#xFFFF};
+@code{\U00@var{nnnnnn}} represents the character whose Unicode code
+point is @samp{U+@var{nnnnnn}}, if such a character is supported by
+Emacs. If the corresponding character is not supported, Emacs signals
+an error.
+
+ This peculiar and inconvenient syntax was adopted for compatibility
+with other programming languages. Unlike some other languages, Emacs
+Lisp supports this syntax in only character literals and strings.
+
+@cindex @samp{\} in character constant
+@cindex backslash in character constant
+@cindex octal character code
+ 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
+@acronym{ASCII} character, it is preferred only when the precise octal
+value is more important than the @acronym{ASCII} representation.
+
+@example
+@group
+?\012 @result{} 10 ?\n @result{} 10 ?\C-j @result{} 10
+?\101 @result{} 65 ?A @result{} 65
+@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
+
+@node Ctl-Char Syntax
+@subsubsection Control-Character Syntax
+
@cindex control characters
- Control characters may be represented using yet another read syntax.
+ Control characters can be represented using yet another read syntax.
This consists of a question mark followed by a backslash, caret, and the
corresponding non-control character, in either upper or lower case. For
example, both @samp{?\^I} and @samp{?\^i} are valid read syntax for the
affect the meaning of the program, but may guide the understanding of
people who read it.
+@node Meta-Char Syntax
+@subsubsection Meta-Character Syntax
+
@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
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}.
+@node Other Char Bits
+@subsubsection Other Character Modifier Bits
+
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
bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
@end ifnottex
-@cindex @samp{\} in character constant
-@cindex backslash in character constant
-@cindex octal character code
- 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 @acronym{ASCII}
-character, it is preferred only when the precise octal value is more
-important than the @acronym{ASCII} representation.
-
-@example
-@group
-?\012 @result{} 10 ?\n @result{} 10 ?\C-j @result{} 10
-?\101 @result{} 65 ?A @result{} 65
-@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. 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} 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 @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 Lisp use, with one single obarray (@pxref{Creating Symbols},
+a symbol's 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
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 was named
-for its purpose, the construction of cells.
+empty list. The empty list is actually the symbol @code{nil}.
+@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.
@cindex atom
Because cons cells are so central to Lisp, we also have a word for
-``an object which is not a cons cell''. These objects are called
+``an object which is not a cons cell.'' These objects are called
@dfn{atoms}.
@cindex parenthesis
+@cindex @samp{(@dots{})} in lists
The read syntax and printed representation for lists are identical, and
consist of a left parenthesis, an arbitrary number of elements, and a
-right parenthesis.
+right parenthesis. Here are examples of lists:
+
+@example
+(A 2 "A") ; @r{A list of three elements.}
+() ; @r{A list of no elements (the empty list).}
+nil ; @r{A list of no elements (the empty list).}
+("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
+(A ()) ; @r{A list of two elements: @code{A} and the empty list.}
+(A nil) ; @r{Equivalent to the previous.}
+((A B C)) ; @r{A list of one element}
+ ; @r{(which is a list of three elements).}
+@end example
Upon reading, each object inside the parentheses becomes an element
of the list. That is, a cons cell is made for each element. The
element in the list. The @sc{cdr} slot of the last cons cell is set to
hold @code{nil}.
+ 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 was named
+for its purpose, the construction of cells.
+
+@menu
+* Box Diagrams:: Drawing pictures of lists.
+* Dotted Pair Notation:: A general syntax for cons cells.
+* Association List Type:: A specially constructed list.
+@end menu
+
+@node Box Diagrams
+@subsubsection Drawing Lists as Box Diagrams
@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, like dominoes. (The Lisp reader cannot read
such an illustration; unlike the textual notation, which can be
@end group
@end smallexample
-@cindex @samp{(@dots{})} in lists
@cindex @code{nil} in lists
@cindex empty list
A list with no elements in it is the @dfn{empty list}; it is identical
to the symbol @code{nil}. In other words, @code{nil} is both a symbol
and a list.
- Here are examples of lists written in Lisp syntax:
-
-@example
-(A 2 "A") ; @r{A list of three elements.}
-() ; @r{A list of no elements (the empty list).}
-nil ; @r{A list of no elements (the empty list).}
-("A ()") ; @r{A list of one element: the string @code{"A ()"}.}
-(A ()) ; @r{A list of two elements: @code{A} and the empty list.}
-(A nil) ; @r{Equivalent to the previous.}
-((A B C)) ; @r{A list of one element}
- ; @r{(which is a list of three elements).}
-@end example
-
Here is the list @code{(A ())}, or equivalently @code{(A nil)},
depicted with boxes and arrows:
@end group
@end example
-@menu
-* Dotted Pair Notation:: An alternative syntax for lists.
-* Association List Type:: A specially constructed list.
-@end menu
+ Here is a more complex illustration, showing the three-element list,
+@code{((pine needles) oak maple)}, the first element of which is a
+two-element list:
+
+@example
+@group
+ --- --- --- --- --- ---
+ | | |--> | | |--> | | |--> nil
+ --- --- --- --- --- ---
+ | | |
+ | | |
+ | --> oak --> maple
+ |
+ | --- --- --- ---
+ --> | | |--> | | |--> nil
+ --- --- --- ---
+ | |
+ | |
+ --> pine --> needles
+@end group
+@end example
+
+ The same list represented in the second box notation looks like this:
+
+@example
+@group
+ -------------- -------------- --------------
+| car | cdr | | car | cdr | | car | cdr |
+| o | o------->| oak | o------->| maple | nil |
+| | | | | | | | | |
+ -- | --------- -------------- --------------
+ |
+ |
+ | -------------- ----------------
+ | | car | cdr | | car | cdr |
+ ------>| pine | o------->| needles | nil |
+ | | | | | |
+ -------------- ----------------
+@end group
+@end example
@node Dotted Pair Notation
-@comment node-name, next, previous, up
@subsubsection Dotted Pair Notation
@cindex dotted pair notation
@cindex @samp{.} in lists
- @dfn{Dotted pair notation} is an alternative syntax for cons cells
-that represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
+ @dfn{Dotted pair notation} is a general syntax for cons cells that
+represents the @sc{car} and @sc{cdr} explicitly. In this syntax,
@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, 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.
+the object @var{a} and whose @sc{cdr} is the object @var{b}. Dotted
+pair notation is more general than list syntax because the @sc{cdr}
+does not have to be a list. However, it is more cumbersome in cases
+where list syntax would work. In dotted 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 an example using boxes to illustrate dotted pair notation.
This example shows the pair @code{(rose . violet)}:
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.
+you can get the same effect with nested one-dimensional 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.
+ The array type is a subset of 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
string (even for an @acronym{ASCII} character) forces the string to be
multibyte.
+ You can also specify characters in a string by their numeric values
+in Unicode, using @samp{\u} and @samp{\U} (@pxref{Character Type}).
+
@xref{Text Representations}, for more information about the two
text representations.
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}.
+Hash tables have no read syntax, and print using hash notation.
+@xref{Hash Tables}, for functions that operate on hash tables.
@example
(make-hash-table)
@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,
-functions in Lisp are primarily Lisp objects, and only secondarily the
-text which represents them. These Lisp objects are lambda expressions:
-lists whose first element is the symbol @code{lambda} (@pxref{Lambda
-Expressions}).
+ Lisp functions are executable code, just like functions in other
+programming languages. In Lisp, unlike most languages, functions are
+also Lisp objects. A non-compiled function in Lisp is a lambda
+expression: that is, a list whose first element is the symbol
+@code{lambda} (@pxref{Lambda Expressions}).
In most programming languages, it is impossible to have a function
without a name. In Lisp, a function has no intrinsic name. A lambda
-expression is also called an @dfn{anonymous function} (@pxref{Anonymous
-Functions}). A named function in Lisp is actually a symbol with a valid
-function in its function cell (@pxref{Defining Functions}).
+expression can be called as a function even though it has no name; to
+emphasize this, we also call it an @dfn{anonymous function}
+(@pxref{Anonymous Functions}). A named function in Lisp is just a
+symbol with a valid function in its function cell (@pxref{Defining
+Functions}).
Most of the time, functions are called when their names are written in
Lisp expressions in Lisp programs. However, you can construct or obtain
A @dfn{primitive function} is a function callable from Lisp but
written in the C programming language. Primitive functions are also
called @dfn{subrs} or @dfn{built-in functions}. (The word ``subr'' is
-derived from ``subroutine''.) Most primitive functions evaluate all
+derived from ``subroutine.'') Most primitive functions evaluate all
their arguments when they are called. A primitive function that does
not evaluate all its arguments is called a @dfn{special form}
(@pxref{Special Forms}).@refill
@node Frame Type
@subsection Frame Type
- 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.
+ A @dfn{frame} is a screen area that contains one or more Emacs
+windows; we also use the term ``frame'' to refer to the Lisp object
+that Emacs uses to refer to the screen area.
Frames have no read syntax. They print in hash notation, giving the
frame's title, plus its address in core (useful to identify the frame
@cindex @samp{#@var{n}=} read syntax
@cindex @samp{#@var{n}#} read syntax
- 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}#}.
+ 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}#}.
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
@node Type Predicates
@section Type Predicates
-@cindex predicates
@cindex type checking
@kindex wrong-type-argument
@item functionp
@xref{Functions, functionp}.
+@item hash-table-p
+@xref{Other Hash, hash-table-p}.
+
@item integer-or-marker-p
@xref{Predicates on Markers, integer-or-marker-p}.
@item windowp
@xref{Basic Windows, windowp}.
+
+@item booleanp
+@xref{nil and t, booleanp}.
+
+@item string-or-null-p
+@xref{Predicates for Strings, string-or-null-p}.
@end table
The most general way to check the type of an object is to call the
@example
(type-of 1)
@result{} integer
+@group
(type-of 'nil)
@result{} symbol
(type-of '()) ; @r{@code{()} is @code{nil}.}
@result{} symbol
(type-of '(x))
@result{} cons
+@end group
@end example
@end defun
@defun eq object1 object2
This function returns @code{t} if @var{object1} and @var{object2} are
-the same object, @code{nil} otherwise. The ``same object'' means that a
-change in one will be reflected by the same change in the other.
+the same object, @code{nil} otherwise.
@code{eq} returns @code{t} if @var{object1} and @var{object2} are
integers with the same value. Also, since symbol names are normally
@code{eq}. For other types (e.g., lists, vectors, strings), two
arguments with the same contents or elements are not necessarily
@code{eq} to each other: they are @code{eq} only if they are the same
-object.
+object, meaning that a change in the contents of one will be reflected
+by the same change in the contents of the other.
@example
@group
@end group
@end example
+@cindex equality of strings
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