Go to the previous, next section.
A symbol is an object with a unique name. This chapter describes symbols, their components, and how they are created and interned. Property lists are also described. The uses of symbols as variables and as function names are described in separate chapters; see section Variables, and section Functions. For the precise syntax for symbols, see section Symbol Type.
You can test whether an arbitrary Lisp object is a symbol
Function: symbolp object
This function returns
t if object is a symbol,
Each symbol has four components (or "cells"), each of which references another object:
symbol-namein section Creating and Interning Symbols.
symbol-valuein section Accessing Variable Values.
symbol-functionin section Accessing Function Cell Contents.
symbol-plistin 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 is done with a hashing algorithm that uses an obarray; see section Creating and Interning Symbols.)
In normal usage, the function cell usually contains a function or
macro, 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 cell 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.
Similarly, the property list cell normally holds 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
nil.) Examining the value of a cell which is void results
in an error, such as `Symbol's value as variable is void'.
The four functions
symbol-function return the contents of
the four cells. Here as an example we show the contents of the four
cells of the symbol
(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
29529) which tells the documentation functions where to find
buffer-file-name in the `DOC' file.
(29529 is the offset from the beginning of the `DOC' file where the
documentation for the function begins.) The function cell contains the
function for returning the name of the file.
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.
defconst are special forms that define a
symbol as a global variable. They are documented in detail in
section Defining Global Variables.
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.) 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 GNU 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
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' can recognize
definitions, and add the appropriate information to tag tables and the
`emacs/etc/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, then it is used. If no such symbol is found, then a new symbol is created and added to the obarray bucket. Adding a symbol to an obarray is called interning it, and the symbol is then called an interned symbol. In Emacs Lisp, a symbol may be interned in only one obarray--if you try to intern the same symbol in more than one obarray, you will get unpredictable results.
It is possible for two different symbols to have the same name in
different obarrays; these symbols are not
However, this normally happens only as part of abbrev definition
(see section Abbrevs And Abbrev Expansion).
Common Lisp note: in Common Lisp, a symbol may be interned in several obarrays at once.
If a symbol is not in the obarray, then there is no way for Lisp to find it when its name is read. Such a symbol is called an uninterned symbol relative to the obarray. An uninterned symbol has all the other characteristics of symbols.
In Emacs Lisp, an obarray is represented as 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
scan the symbols in an obarray except using
The order of symbols in a bucket is not significant.
In an empty obarray, every element is 0, and you can create an obarray
(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
Do not try to create an obarray that is not empty. This
does not work--only
intern can enter a symbol in an obarray
properly. Also, don't try to put into an obarray of your own
a symbol that is already interned in the main obarray, because in
Emacs Lisp a symbol cannot be in two obarrays at once.
Most of the functions below take a name and sometimes an obarray as
wrong-type-argument error is signaled if the name
is not a string, or if the obarray is not a vector.
Function: symbol-name symbol
This function returns the string that is symbol's name. For example:
(symbol-name 'foo) => "foo"
Changing the string by substituting characters, etc, does change the name of the symbol, but fails to update the obarray, so don't do it!
Function: make-symbol name
This function returns a newly-allocated, uninterned symbol whose name is
name (which must be a string). Its value and function definition
are void, and its property list is
nil. In the example below,
the value of
sym is not
foo because it is a
distinct uninterned symbol whose name is also `foo'.
(setq sym (make-symbol "foo")) => foo (eq sym 'foo) => nil
Function: intern name &optional obarray
This function returns the interned symbol whose name is name. If
there is no such symbol in the obarray, a new one is created, added to
the obarray, and returned. If obarray is supplied, it specifies
the obarray to use; otherwise, 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
Function: intern-soft name &optional obarray
This function returns the symbol whose name is name, or
if a symbol with that name is not found in the obarray. Therefore, you
intern-soft to test whether a symbol with a given name is
interned. If obarray is supplied, it specifies the obarray to
use; otherwise 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
This variable is the standard obarray for use by
Function: mapatoms function &optional obarray
This function applies function to every symbol in obarray.
nil. If obarray is not supplied, 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
documentation in section Access to Documentation Strings, for another
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 how to compile it, 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. They are compared 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)
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 when it is necessary
to attach information to various Lisp function names or variables. If
all the pairs are recorded in one association list, the program will
need to search that entire list each time a function or variable is to
be operated on. By contrast, if the information is recorded 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. For this reason, 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
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 use property names that are probably unique, such as by including the name of the library in the property name.) 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.
Function: symbol-plist symbol
This function returns the property list of symbol.
Function: setplist symbol plist
This function sets symbol's property list to plist. Normally, plist should be a well-formed property list, but this is not enforced.
(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).
Function: get symbol property
This function finds the value of the property named property in
symbol's property list. If there is no such property,
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
eq, so any object is a legitimate property.
put for an example.
Function: put symbol property value
This function puts value onto symbol's property list under the property name property, replacing any previous 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))
Go to the previous, next section.