2 @c This is part of the SXEmacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 @c Copyright (C) 2005 Sebastian Freundt <hroptatyr@sxemacs.org>
5 @c See the file lispref.texi for copying conditions.
6 @setfilename ../../info/symbols.info
8 @node Symbols, Evaluation, Sequences Arrays Vectors, Top
12 A @dfn{symbol} is an object with a unique name. This chapter
13 describes symbols, their components, their property lists, and how they
14 are created and interned. Separate chapters describe the use of symbols
15 as variables and as function names; see @ref{Variables}, and
16 @ref{Functions and Commands}. For the precise read syntax for symbols,
17 see @ref{Symbol Type}.
19 You can test whether an arbitrary Lisp object is a symbol
23 This function returns @code{t} if @var{object} is a symbol, @code{nil}
28 * Symbol Components:: Symbols have names, values, function definitions
30 * Definitions:: A definition says how a symbol will be used.
31 * Creating Symbols:: How symbols are kept unique.
32 * Symbol Properties:: Each symbol has a property list
33 for recording miscellaneous information.
37 @node Symbol Components, Definitions, Symbols, Symbols
38 @section Symbol Components
39 @cindex symbol components
41 Each symbol has four components (or ``cells''), each of which
42 references another object:
46 @cindex print name cell
47 The @dfn{print name cell} holds a string that names the symbol for
48 reading and printing. See @code{symbol-name} in @ref{Creating Symbols}.
52 The @dfn{value cell} holds the current value of the symbol as a
53 variable. When a symbol is used as a form, the value of the form is the
54 contents of the symbol's value cell. See @code{symbol-value} in
55 @ref{Accessing Variables}.
59 The @dfn{function cell} holds the function definition of the symbol.
60 When a symbol is used as a function, its function definition is used in
61 its place. This cell is also used to make a symbol stand for a keymap
62 or a keyboard macro, for editor command execution. Because each symbol
63 has separate value and function cells, variables and function names do
64 not conflict. See @code{symbol-function} in @ref{Function Cells}.
67 @cindex property list cell (symbol)
68 The @dfn{property list cell} holds the property list of the symbol. See
69 @code{symbol-plist} in @ref{Symbol Properties}.
72 The print name cell always holds a string, and cannot be changed. The
73 other three cells can be set individually to any specified Lisp object.
75 The print name cell holds the string that is the name of the symbol.
76 Since symbols are represented textually by their names, it is important
77 not to have two symbols with the same name. The Lisp reader ensures
78 this: every time it reads a symbol, it looks for an existing symbol with
79 the specified name before it creates a new one. (In SXEmacs Lisp,
80 this lookup uses a hashing algorithm and an obarray; see @ref{Creating
83 In normal usage, the function cell usually contains a function or
84 macro, as that is what the Lisp interpreter expects to see there
85 (@pxref{Evaluation}). Keyboard macros (@pxref{Keyboard Macros}),
86 keymaps (@pxref{Keymaps}) and autoload objects (@pxref{Autoloading}) are
87 also sometimes stored in the function cell of symbols. We often refer
88 to ``the function @code{foo}'' when we really mean the function stored
89 in the function cell of the symbol @code{foo}. We make the distinction
92 The property list cell normally should hold a correctly formatted
93 property list (@pxref{Property Lists}), as a number of functions expect
94 to see a property list there.
96 The function cell or the value cell may be @dfn{void}, which means
97 that the cell does not reference any object. (This is not the same
98 thing as holding the symbol @code{void}, nor the same as holding the
99 symbol @code{nil}.) Examining a cell that is void results in an error,
100 such as @samp{Symbol's value as variable is void}.
102 The four functions @code{symbol-name}, @code{symbol-value},
103 @code{symbol-plist}, and @code{symbol-function} return the contents of
104 the four cells of a symbol. Here as an example we show the contents of
105 the four cells of the symbol @code{buffer-file-name}:
108 (symbol-name 'buffer-file-name)
109 @result{} "buffer-file-name"
110 (symbol-value 'buffer-file-name)
111 @result{} "/gnu/elisp/symbols.texi"
112 (symbol-plist 'buffer-file-name)
113 @result{} (variable-documentation 29529)
114 (symbol-function 'buffer-file-name)
115 @result{} #<subr buffer-file-name>
119 Because this symbol is the variable which holds the name of the file
120 being visited in the current buffer, the value cell contents we see are
121 the name of the source file of this chapter of the XEmacs Lisp Reference
123 The property list cell contains the list @code{(variable-documentation
124 29529)} which tells the documentation functions where to find the
125 documentation string for the variable @code{buffer-file-name} in the
126 @file{DOC} file. (29529 is the offset from the beginning of the
127 @file{DOC} file to where that documentation string begins.) The
128 function cell contains the function for returning the name of the file.
129 @code{buffer-file-name} names a primitive function, which has no read
130 syntax and prints in hash notation (@pxref{Primitive Function Type}). A
131 symbol naming a function written in Lisp would have a lambda expression
132 (or a byte-code object) in this cell.
136 @section Defining Symbols
137 @cindex definition of a symbol
139 A @dfn{definition} in Lisp is a special form that announces your
140 intention to use a certain symbol in a particular way. In SXEmacs Lisp,
141 you can define a symbol as a variable, or define it as a function (or
142 macro), or both independently.
144 A definition construct typically specifies a value or meaning for the
145 symbol for one kind of use, plus documentation for its meaning when used
146 in this way. Thus, when you define a symbol as a variable, you can
147 supply an initial value for the variable, plus documentation for the
150 @code{defvar} and @code{defconst} are special forms that define a
151 symbol as a global variable. They are documented in detail in
152 @ref{Defining Variables}.
154 @code{defun} defines a symbol as a function, creating a lambda
155 expression and storing it in the function cell of the symbol. This
156 lambda expression thus becomes the function definition of the symbol.
157 (The term ``function definition'', meaning the contents of the function
158 cell, is derived from the idea that @code{defun} gives the symbol its
159 definition as a function.) @code{defsubst}, @code{define-function} and
160 @code{defalias} are other ways of defining a function.
161 @xref{Functions and Commands}.
163 @code{defmacro} defines a symbol as a macro. It creates a macro
164 object and stores it in the function cell of the symbol. Note that a
165 given symbol can be a macro or a function, but not both at once, because
166 both macro and function definitions are kept in the function cell, and
167 that cell can hold only one Lisp object at any given time.
170 In SXEmacs Lisp, a definition is not required in order to use a symbol
171 as a variable or function. Thus, you can make a symbol a global
172 variable with @code{setq}, whether you define it first or not. The real
173 purpose of definitions is to guide programmers and programming tools.
174 They inform programmers who read the code that certain symbols are
175 @emph{intended} to be used as variables, or as functions. In addition,
176 utilities such as @file{etags} and @file{make-docfile} recognize
177 definitions, and add appropriate information to tag tables and the
178 @file{DOC} file. @xref{Accessing Documentation}.
181 @node Creating Symbols
182 @section Creating and Interning Symbols
183 @cindex reading symbols
185 To understand how symbols are created in SXEmacs Lisp, you must know
186 how Lisp reads them. Lisp must ensure that it finds the same symbol
187 every time it reads the same set of characters. Failure to do so would
188 cause complete confusion.
190 @cindex symbol name hashing
193 @cindex bucket (in obarray)
194 When the Lisp reader encounters a symbol, it reads all the characters
195 of the name. Then it ``hashes'' those characters to find an index in a
196 table called an @dfn{obarray}. Hashing is an efficient method of
197 looking something up. For example, instead of searching a telephone
198 book cover to cover when looking up Jan Jones, you start with the J's
199 and go from there. That is a simple version of hashing. Each element
200 of the obarray is a @dfn{bucket} which holds all the symbols with a
201 given hash code; to look for a given name, it is sufficient to look
202 through all the symbols in the bucket for that name's hash code.
205 If a symbol with the desired name is found, the reader uses that
206 symbol. If the obarray does not contain a symbol with that name, the
207 reader makes a new symbol and adds it to the obarray. Finding or adding
208 a symbol with a certain name is called @dfn{interning} it, and the
209 symbol is then called an @dfn{interned symbol}.
211 Interning ensures that each obarray has just one symbol with any
212 particular name. Other like-named symbols may exist, but not in the
213 same obarray. Thus, the reader gets the same symbols for the same
214 names, as long as you keep reading with the same obarray.
216 @cindex symbol equality
217 @cindex uninterned symbol
218 No obarray contains all symbols; in fact, some symbols are not in any
219 obarray. They are called @dfn{uninterned symbols}. An uninterned
220 symbol has the same four cells as other symbols; however, the only way
221 to gain access to it is by finding it in some other object or as the
224 In SXEmacs Lisp, an obarray is actually a vector. Each element of the
225 vector is a bucket; its value is either an interned symbol whose name
226 hashes to that bucket, or 0 if the bucket is empty. Each interned
227 symbol has an internal link (invisible to the user) to the next symbol
228 in the bucket. Because these links are invisible, there is no way to
229 find all the symbols in an obarray except using @code{mapatoms} (below).
230 The order of symbols in a bucket is not significant.
232 In an empty obarray, every element is 0, and you can create an obarray
233 with @code{(make-vector @var{length} 0)}. @strong{This is the only
234 valid way to create an obarray.} Prime numbers as lengths tend
235 to result in good hashing; lengths one less than a power of two are also
238 @strong{Do not try to put symbols in an obarray yourself.} This does
239 not work---only @code{intern} can enter a symbol in an obarray properly.
240 @strong{Do not try to intern one symbol in two obarrays.} This would
241 garble both obarrays, because a symbol has just one slot to hold the
242 following symbol in the obarray bucket. The results would be
245 It is possible for two different symbols to have the same name in
246 different obarrays; these symbols are not @code{eq} or @code{equal}.
247 However, this normally happens only as part of the abbrev mechanism
250 @cindex CL note---symbol in obarrays
252 @b{Common Lisp note:} In Common Lisp, a single symbol may be interned in
256 Most of the functions below take a name and sometimes an obarray as
257 arguments. A @code{wrong-type-argument} error is signaled if the name
258 is not a string, or if the obarray is not a vector.
260 @defun symbol-name symbol
261 This function returns the string that is @var{symbol}'s name. For example:
270 Changing the string by substituting characters, etc, does change the
271 name of the symbol, but fails to update the obarray, so don't do it!
274 @defun make-symbol name
275 This function returns a newly-allocated, uninterned symbol whose name is
276 @var{name} (which must be a string). Its value and function definition
277 are void, and its property list is @code{nil}. In the example below,
278 the value of @code{sym} is not @code{eq} to @code{foo} because it is a
279 distinct uninterned symbol whose name is also @samp{foo}.
282 (setq sym (make-symbol "foo"))
289 @defun intern name &optional obarray
290 This function returns the interned symbol whose name is @var{name}. If
291 there is no such symbol in the obarray @var{obarray}, @code{intern}
292 creates a new one, adds it to the obarray, and returns it. If
293 @var{obarray} is omitted, the value of the global variable
294 @code{obarray} is used.
297 (setq sym (intern "foo"))
302 (setq sym1 (intern "foo" other-obarray))
309 @defun intern-soft name &optional obarray
310 This function returns the symbol in @var{obarray} whose name is
311 @var{name}, or @code{nil} if @var{obarray} has no symbol with that name.
312 Therefore, you can use @code{intern-soft} to test whether a symbol with
313 a given name is already interned. If @var{obarray} is omitted, the
314 value of the global variable @code{obarray} is used.
317 (intern-soft "frazzle") ; @r{No such symbol exists.}
319 (make-symbol "frazzle") ; @r{Create an uninterned one.}
322 (intern-soft "frazzle") ; @r{That one cannot be found.}
326 (setq sym (intern "frazzle")) ; @r{Create an interned one.}
330 (intern-soft "frazzle") ; @r{That one can be found!}
334 (eq sym 'frazzle) ; @r{And it is the same one.}
341 This variable is the standard obarray for use by @code{intern} and
345 @defun mapatoms function &optional obarray
346 This function calls @var{function} for each symbol in the obarray
347 @var{obarray}. It returns @code{nil}. If @var{obarray} is omitted, it
348 defaults to the value of @code{obarray}, the standard obarray for
354 (defun count-syms (s)
355 (setq count (1+ count)))
357 (mapatoms 'count-syms)
363 See @code{documentation} in @ref{Accessing Documentation}, for another
364 example using @code{mapatoms}.
367 @defun unintern symbol &optional obarray
368 This function deletes @var{symbol} from the obarray @var{obarray}. If
369 @code{symbol} is not actually in the obarray, @code{unintern} does
370 nothing. If @var{obarray} is @code{nil}, the current obarray is used.
372 If you provide a string instead of a symbol as @var{symbol}, it stands
373 for a symbol name. Then @code{unintern} deletes the symbol (if any) in
374 the obarray which has that name. If there is no such symbol,
375 @code{unintern} does nothing.
377 If @code{unintern} does delete a symbol, it returns @code{t}. Otherwise
378 it returns @code{nil}.
382 @node Symbol Properties, , Creating Symbols, Symbols
383 @section Symbol Properties
384 @cindex property list, symbol
385 @cindex plist, symbol
387 A @dfn{property list} (@dfn{plist} for short) is a list of paired
388 elements, often stored in the property list cell of a symbol. Each of
389 the pairs associates a property name (usually a symbol) with a property
390 or value. Property lists are generally used to record information about
391 a symbol, such as its documentation as a variable, the name of the file
392 where it was defined, or perhaps even the grammatical class of the
393 symbol (representing a word) in a language-understanding system.
395 Some objects which are not symbols also have property lists associated
396 with them, and SXEmacs provides a full complement of functions for
397 working with property lists. @xref{Property Lists}.
399 The property names and values in a property list can be any Lisp
400 objects, but the names are usually symbols. They are compared using
401 @code{eq}. Here is an example of a property list, found on the symbol
402 @code{progn} when the compiler is loaded:
405 (lisp-indent-function 0 byte-compile byte-compile-progn)
409 Here @code{lisp-indent-function} and @code{byte-compile} are property
410 names, and the other two elements are the corresponding values.
413 * Plists and Alists:: Comparison of the advantages of property
414 lists and association lists.
415 * Object Plists:: Functions to access objects' property lists.
416 * Other Plists:: Accessing property lists stored elsewhere.
420 @node Plists and Alists
421 @subsection Property Lists and Association Lists
423 @cindex property lists vs association lists
424 Association lists (@pxref{Association Lists}) are very similar to
425 property lists. In contrast to association lists, the order of the
426 pairs in the property list is not significant since the property names
429 Property lists are better than association lists for attaching
430 information to various Lisp function names or variables. If all the
431 associations are recorded in one association list, the program will need
432 to search that entire list each time a function or variable is to be
433 operated on. By contrast, if the information is recorded in the
434 property lists of the function names or variables themselves, each
435 search will scan only the length of one property list, which is usually
436 short. This is why the documentation for a variable is recorded in a
437 property named @code{variable-documentation}. The byte compiler
438 likewise uses properties to record those functions needing special
441 However, association lists have their own advantages. Depending on
442 your application, it may be faster to add an association to the front of
443 an association list than to update a property. All properties for a
444 symbol are stored in the same property list, so there is a possibility
445 of a conflict between different uses of a property name. (For this
446 reason, it is a good idea to choose property names that are probably
447 unique, such as by including the name of the library in the property
448 name.) An association list may be used like a stack where associations
449 are pushed on the front of the list and later discarded; this is not
450 possible with a property list.
454 @subsection Property List Functions for Objects
456 Once upon a time, only symbols had property lists. Now, several other
457 object types, including strings, extents, faces and glyphs also have
460 @defun symbol-plist symbol
461 This function returns the property list of @var{symbol}.
464 @defun object-plist object
465 This function returns the property list of @var{object}. If
466 @var{object} is a symbol, this is identical to @code{symbol-plist}.
469 @defun setplist symbol plist
470 This function sets @var{symbol}'s property list to @var{plist}.
471 Normally, @var{plist} should be a well-formed property list, but this is
475 (setplist 'foo '(a 1 b (2 3) c nil))
476 @result{} (a 1 b (2 3) c nil)
478 @result{} (a 1 b (2 3) c nil)
481 For symbols in special obarrays, which are not used for ordinary
482 purposes, it may make sense to use the property list cell in a
483 nonstandard fashion; in fact, the abbrev mechanism does so
484 (@pxref{Abbrevs}). But generally, its use is discouraged. Use
485 @code{put} instead. @code{setplist} can only be used with symbols, not
489 @defun get object property &optional default
490 This function finds the value of the property named @var{property} in
491 @var{object}'s property list. If there is no such property,
492 @code{default} (which itself defaults to @code{nil}) is returned.
494 @var{property} is compared with the existing properties using @code{eq},
495 so any object is a legitimate property.
497 See @code{put} for an example.
500 @defun put object property value
501 This function puts @var{value} onto @var{object}'s property list under
502 the property name @var{property}, replacing any previous property value.
503 The @code{put} function returns @var{value}.
506 (put 'fly 'verb 'transitive)
508 (put 'fly 'noun '(a buzzing little bug))
509 @result{} (a buzzing little bug)
513 @result{} (verb transitive noun (a buzzing little bug))
517 @defun remprop object property
518 This function removes the entry for @var{property} from the property
519 list of @var{object}. It returns @code{t} if the property was
520 indeed found and removed, or @code{nil} if there was no such property.
521 (This function was probably omitted from Emacs originally because,
522 since @code{get} did not allow a @var{default}, it was very difficult
523 to distinguish between a missing property and a property whose value
524 was @code{nil}; thus, setting a property to @code{nil} was close
525 enough to @code{remprop} for most purposes.)
530 @subsection Property Lists Not Associated with Objects
532 These functions are useful for manipulating property lists
533 that are stored in places other than symbols:
535 @defun getf plist property &optional default
536 This returns the value of the @var{property} property
537 stored in the property list @var{plist}. For example,
545 @defmac putf plist property value
546 This stores @var{value} as the value of the @var{property} property in
547 the property list @var{plist}. It may modify @var{plist} destructively,
548 or it may construct a new list structure without altering the old. The
549 function returns the modified property list, so you can store that back
550 in the place where you got @var{plist}. For example,
553 (setq my-plist '(bar t foo 4))
554 @result{} (bar t foo 4)
555 (setq my-plist (putf my-plist 'foo 69))
556 @result{} (bar t foo 69)
557 (setq my-plist (putf my-plist 'quux '(a)))
558 @result{} (quux (a) bar t foo 5)
563 This function returns non-@code{nil} if property lists @var{a} and @var{b}
564 are @code{eq}. This means that the property lists have the same values
565 for all the same properties, where comparison between values is done using
569 @defun plists-equal a b
570 This function returns non-@code{nil} if property lists @var{a} and @var{b}
574 Both of the above functions do order-insensitive comparisons.
577 (plists-eq '(a 1 b 2 c nil) '(b 2 a 1))
579 (plists-eq '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello"))
581 (plists-equal '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello"))