@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
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}: 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{>}. For example:
+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)
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.
@cindex control characters
bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
@end ifnottex
+@cindex unicode character escape
+ Emacs provides a syntax for specifying characters by their Unicode
+code points. @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
@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. Here are examples of lists:
@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
@end group
@end example
- The same list represented in the first box notation looks like this:
+ The same list represented in the second box notation looks like this:
@example
@group
@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
+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
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 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
@node Type Predicates
@section Type Predicates
-@cindex predicates
@cindex type checking
@kindex wrong-type-argument
@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
@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