A symbol is an object with a unique name. This chapter describes symbols, their components, their property lists, and how they are created and interned. Separate chapters describe the use of symbols as variables and as function names; see section Variables, and section Functions. For the precise read syntax for symbols, see section Symbol Type.
You can test whether an arbitrary Lisp object is a symbol with
symbolp:
t if object is a symbol, nil
otherwise.
Each symbol has four components (or "cells"), each of which references another object:
symbol-name in section Creating and Interning Symbols.
symbol-value in section Accessing Variable Values.
symbol-function in section Accessing Function Cell Contents.
symbol-plist in section Property Lists.
The print name cell always holds a string, and cannot be changed. The other three cells can be set individually to any specified Lisp object.
The print name cell holds the string that is the name of the symbol. Since symbols are represented textually by their names, it is important not to have two symbols with the same name. The Lisp reader ensures this: every time it reads a symbol, it looks for an existing symbol with the specified name before it creates a new one. (In GNU Emacs Lisp, this lookup uses a hashing algorithm and an obarray; see section Creating and Interning Symbols.)
In normal usage, the function cell usually contains a function
(see section Functions) or a macro
(see section Macros), as that is
what the Lisp interpreter expects to see there (see section Evaluation). Keyboard macros (see
section Keyboard Macros), keymaps
(see section Keymaps) and autoload
objects (see section Autoloading)
are also sometimes stored in the function cells of symbols. We
often refer to "the function foo" when we really mean
the function stored in the function cell of the symbol
foo. We make the distinction only when necessary.
The property list cell normally should hold a correctly formatted property list (see section Property Lists), as a number of functions expect to see a property list there.
The function cell or the value cell may be void, which
means that the cell does not reference any object. (This is not the
same thing as holding the symbol void, nor the same as
holding the symbol nil.) Examining a function or value
cell that is void results in an error, such as `Symbol's
value as variable is void'.
The four functions symbol-name,
symbol-value, symbol-plist, and
symbol-function return the contents of the four cells
of a symbol. Here as an example we show the contents of the four
cells of the symbol buffer-file-name:
(symbol-name 'buffer-file-name)
=> "buffer-file-name"
(symbol-value 'buffer-file-name)
=> "/gnu/elisp/symbols.texi"
(symbol-plist 'buffer-file-name)
=> (variable-documentation 29529)
(symbol-function 'buffer-file-name)
=> #<subr buffer-file-name>
Because this symbol is the variable which holds the name of the
file being visited in the current buffer, the value cell contents
we see are the name of the source file of this chapter of the Emacs
Lisp Manual. The property list cell contains the list
(variable-documentation 29529) which tells the
documentation functions where to find the documentation string for
the variable buffer-file-name in the
`DOC-version' file. (29529 is the offset from
the beginning of the `DOC-version' file to
where that documentation string begins--see section Documentation Basics.) The function
cell contains the function for returning the name of the file.
buffer-file-name names a primitive function, which has
no read syntax and prints in hash notation (see section Primitive Function Type). A symbol
naming a function written in Lisp would have a lambda expression
(or a byte-code object) in this cell.
A definition in Lisp is a special form that announces your intention to use a certain symbol in a particular way. In Emacs Lisp, you can define a symbol as a variable, or define it as a function (or macro), or both independently.
A definition construct typically specifies a value or meaning for the symbol for one kind of use, plus documentation for its meaning when used in this way. Thus, when you define a symbol as a variable, you can supply an initial value for the variable, plus documentation for the variable.
defvar and defconst are special forms
that define a symbol as a global variable. They are documented in
detail in section Defining Global
Variables. For defining user option variables that can be
customized, use defcustom (see section Writing Customization
Definitions).
defun defines a symbol as a function, creating a
lambda expression and storing it in the function cell of the
symbol. This lambda expression thus becomes the function definition
of the symbol. (The term "function definition", meaning the
contents of the function cell, is derived from the idea that
defun gives the symbol its definition as a function.)
defsubst and defalias are two other ways
of defining a function. See section Functions.
defmacro defines a symbol as a macro. It creates a
macro object and stores it in the function cell of the symbol. Note
that a given symbol can be a macro or a function, but not both at
once, because both macro and function definitions are kept in the
function cell, and that cell can hold only one Lisp object at any
given time. See section Macros.
In Emacs Lisp, a definition is not required in order to use a
symbol as a variable or function. Thus, you can make a symbol a
global variable with setq, whether you define it first
or not. The real purpose of definitions is to guide programmers and
programming tools. They inform programmers who read the code that
certain symbols are intended to be used as variables, or
as functions. In addition, utilities such as `etags' and
`make-docfile' recognize definitions, and add appropriate
information to tag tables and the `DOC-version'
file. See section Access to
Documentation Strings.
To understand how symbols are created in GNU Emacs Lisp, you must know how Lisp reads them. Lisp must ensure that it finds the same symbol every time it reads the same set of characters. Failure to do so would cause complete confusion.
When the Lisp reader encounters a symbol, it reads all the characters of the name. Then it "hashes" those characters to find an index in a table called an obarray. Hashing is an efficient method of looking something up. For example, instead of searching a telephone book cover to cover when looking up Jan Jones, you start with the J's and go from there. That is a simple version of hashing. Each element of the obarray is a bucket which holds all the symbols with a given hash code; to look for a given name, it is sufficient to look through all the symbols in the bucket for that name's hash code.
If a symbol with the desired name is found, the reader uses that symbol. If the obarray does not contain a symbol with that name, the reader makes a new symbol and adds it to the obarray. Finding or adding a symbol with a certain name is called interning it, and the symbol is then called an interned symbol.
Interning ensures that each obarray has just one symbol with any particular name. Other like-named symbols may exist, but not in the same obarray. Thus, the reader gets the same symbols for the same names, as long as you keep reading with the same obarray.
No obarray contains all symbols; in fact, some symbols are not in any obarray. They are called uninterned symbols. An uninterned symbol has the same four cells as other symbols; however, the only way to gain access to it is by finding it in some other object or as the value of a variable.
In Emacs Lisp, an obarray is actually a vector. Each element of
the vector is a bucket; its value is either an interned symbol
whose name hashes to that bucket, or 0 if the bucket is empty. Each
interned symbol has an internal link (invisible to the user) to the
next symbol in the bucket. Because these links are invisible, there
is no way to find all the symbols in an obarray except using
mapatoms (below). The order of symbols in a bucket is
not significant.
In an empty obarray, every element is 0, and you can create an
obarray with (make-vector length 0).
This is the only valid way to create an obarray.
Prime numbers as lengths tend to result in good hashing; lengths
one less than a power of two are also good.
Do not try to put symbols in an obarray
yourself. This does not work--only intern can
enter a symbol in an obarray properly.
Common Lisp note: In Common Lisp, a single symbol may be interned in several obarrays.
Most of the functions below take a name and sometimes an obarray
as arguments. A wrong-type-argument error is signaled
if the name is not a string, or if the obarray is not a vector.
(symbol-name 'foo)
=> "foo"
Warning: Changing the string by substituting characters does change the name of the symbol, but fails to update the obarray, so don't do it!
nil. In the example
below, the value of sym is not eq to
foo because it is a distinct uninterned symbol whose
name is also `foo'.
(setq sym (make-symbol "foo"))
=> foo
(eq sym 'foo)
=> nil
intern
creates a new one, adds it to the obarray, and returns it. If
obarray is omitted, the value of the global variable
obarray is used.
(setq sym (intern "foo"))
=> foo
(eq sym 'foo)
=> t
(setq sym1 (intern "foo" other-obarray))
=> foo
(eq sym 'foo)
=> nil
Common Lisp note: In Common Lisp, you can intern an existing symbol in an obarray. In Emacs Lisp, you cannot do this, because the argument to
internmust be a string, not a symbol.
nil if obarray has no symbol with that
name. Therefore, you can use intern-soft to test
whether a symbol with a given name is already interned. If
obarray is omitted, the value of the global variable
obarray is used.
(intern-soft "frazzle") ; No such symbol exists.
=> nil
(make-symbol "frazzle") ; Create an uninterned one.
=> frazzle
(intern-soft "frazzle") ; That one cannot be found.
=> nil
(setq sym (intern "frazzle")) ; Create an interned one.
=> frazzle
(intern-soft "frazzle") ; That one can be found!
=> frazzle
(eq sym 'frazzle) ; And it is the same one.
=> t
intern and read.
nil. If
obarray is omitted, it defaults to the value of
obarray, the standard obarray for ordinary symbols.
(setq count 0)
=> 0
(defun count-syms (s)
(setq count (1+ count)))
=> count-syms
(mapatoms 'count-syms)
=> nil
count
=> 1871
See documentation in section Access to Documentation Strings, for
another example using mapatoms.
symbol is not actually in the obarray,
unintern does nothing. If obarray is
nil, the current obarray is used. If you provide a string instead of a symbol as
symbol, it stands for a symbol name. Then
unintern deletes the symbol (if any) in the obarray
which has that name. If there is no such symbol,
unintern does nothing.
If unintern does delete a symbol, it returns
t. Otherwise it returns nil.
A property list (plist for short) is a list of paired elements stored in the property list cell of a symbol. Each of the pairs associates a property name (usually a symbol) with a property or value. Property lists are generally used to record information about a symbol, such as its documentation as a variable, the name of the file where it was defined, or perhaps even the grammatical class of the symbol (representing a word) in a language-understanding system.
Character positions in a string or buffer can also have property lists. See section Text Properties.
The property names and values in a property list can be any Lisp
objects, but the names are usually symbols. Property list functions
compare the property names using eq. Here is an
example of a property list, found on the symbol progn
when the compiler is loaded:
(lisp-indent-function 0 byte-compile byte-compile-progn)
Here lisp-indent-function and
byte-compile are property names, and the other two
elements are the corresponding values.
Association lists (see section Association Lists) are very similar to property lists. In contrast to association lists, the order of the pairs in the property list is not significant since the property names must be distinct.
Property lists are better than association lists for attaching
information to various Lisp function names or variables. If your
program keeps all of its associations in one association list, it
will typically need to search that entire list each time it checks
for an association. This could be slow. By contrast, if you keep
the same information in the property lists of the function names or
variables themselves, each search will scan only the length of one
property list, which is usually short. This is why the
documentation for a variable is recorded in a property named
variable-documentation. The byte compiler likewise
uses properties to record those functions needing special
treatment.
However, association lists have their own advantages. Depending on your application, it may be faster to add an association to the front of an association list than to update a property. All properties for a symbol are stored in the same property list, so there is a possibility of a conflict between different uses of a property name. (For this reason, it is a good idea to choose property names that are probably unique, such as by beginning the property name with the program's usual name-prefix for variables and functions.) An association list may be used like a stack where associations are pushed on the front of the list and later discarded; this is not possible with a property list.
(setplist 'foo '(a 1 b (2 3) c nil))
=> (a 1 b (2 3) c nil)
(symbol-plist 'foo)
=> (a 1 b (2 3) c nil)
For symbols in special obarrays, which are not used for ordinary purposes, it may make sense to use the property list cell in a nonstandard fashion; in fact, the abbrev mechanism does so (see section Abbrevs And Abbrev Expansion).
nil is
returned. Thus, there is no distinction between a value of
nil and the absence of the property. The name property is compared with the existing
property names using eq, so any object is a legitimate
property.
See put for an example.
put function returns value.
(put 'fly 'verb 'transitive)
=>'transitive
(put 'fly 'noun '(a buzzing little bug))
=> (a buzzing little bug)
(get 'fly 'verb)
=> transitive
(symbol-plist 'fly)
=> (verb transitive noun (a buzzing little bug))
These two functions are useful for manipulating property lists that are stored in places other than symbols:
(plist-get '(foo 4) 'foo)
=> 4
(setq my-plist '(bar t foo 4))
=> (bar t foo 4)
(setq my-plist (plist-put my-plist 'foo 69))
=> (bar t foo 69)
(setq my-plist (plist-put my-plist 'quux '(a)))
=> (bar t foo 69 quux (a))
You could define put in terms of
plist-put as follows:
(defun put (symbol prop value)
(setplist symbol
(plist-put (symbol-plist symbol) prop value)))