Symbols
*******

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 Variables, and Functions and Commands.  For the precise read syntax for symbols, see Symbol Type.

You can test whether an arbitrary Lisp object is a symbol with symbolp:

 -- Function: symbolp object
     This function returns t if OBJECT is a symbol, nil otherwise.

Symbol Components
=================

Each symbol has four components (or ``cells''), each of which references another object:

Print name
     The print name cell holds a string that names the symbol for reading and printing.  See symbol-name in Creating Symbols.

Value
     The value cell holds the current value of the symbol as a variable.  When a symbol is used as a form, the value of the form is the contents of the symbol's value cell.  See symbol-value in Accessing Variables.

Function
     The function cell holds the function definition of the symbol. When a symbol is used as a function, its function definition is used in its place.  This cell is also used to make a symbol stand for a keymap or a keyboard macro, for editor command execution.  Because each symbol has separate value and function cells, variables and function names do not conflict.  See symbol-function in Function Cells.

Property list
     The property list cell holds the property list of the symbol.  See symbol-plist in Symbol Properties.

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 SXEmacs Lisp, this lookup uses a hashing algorithm and an obarray; see Creating 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 Evaluation).  Keyboard macros (see Keyboard Macros), keymaps (see Keymaps) and autoload objects (see 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.

The property list cell normally should hold a correctly formatted property list (see 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 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 XEmacs Lisp Reference 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 file.  (29529 is the offset from the beginning of the DOC file to where that documentation string begins.)  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 Primitive Function Type).  A symbol naming a function written in Lisp would have a lambda expression (or a byte-code object) in this cell.

Defining Symbols
================

A definition in Lisp is a special form that announces your intention to use a certain symbol in a particular way.  In SXEmacs 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 Defining 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.)  defsubst, define-function and defalias are other ways of defining a function. See Functions and Commands.

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 Macros.

In SXEmacs 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 file. See Accessing Documentation.

Creating and Interning Symbols
==============================

To understand how symbols are created in SXEmacs 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 SXEmacs 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. Do not try to intern one symbol in two obarrays.  This would garble both obarrays, because a symbol has just one slot to hold the following symbol in the obarray bucket.  The results would be unpredictable.

It is possible for two different symbols to have the same name in different obarrays; these symbols are not eq or equal. However, this normally happens only as part of the abbrev mechanism (see Abbrevs).

     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.

 -- 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 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

 -- Function: intern name &optional obarray
     This function returns the interned symbol whose name is NAME.  If there is no such symbol in the obarray OBARRAY, 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

 -- Function: intern-soft name &optional obarray
     This function returns the symbol in OBARRAY whose name is NAME, or 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

 -- Variable: obarray
     This variable is the standard obarray for use by intern and read.

 -- Function: mapatoms function &optional obarray
     This function calls FUNCTION for each symbol in the obarray OBARRAY.  It returns 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 Accessing Documentation, for another example using mapatoms.

 -- Function: unintern symbol &optional obarray
     This function deletes SYMBOL from the obarray OBARRAY.  If 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.

Symbol Properties
=================

A property list (plist for short) is a list of paired elements, often 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.

Some objects which are not symbols also have property lists associated with them, and SXEmacs provides a full complement of functions for working with property lists.  See Property Lists.

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)

Here lisp-indent-function and byte-compile are property names, and the other two elements are the corresponding values.

Property Lists and Association Lists
------------------------------------

Association lists (see 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 all the associations 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.  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 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.

Property List Functions for Objects
-----------------------------------

Once upon a time, only symbols had property lists.  Now, several other object types, including strings, extents, faces and glyphs also have property lists.

 -- Function: symbol-plist symbol
     This function returns the property list of SYMBOL.

 -- Function: object-plist object
     This function returns the property list of OBJECT.  If OBJECT is a symbol, this is identical to symbol-plist.

 -- 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 Abbrevs).  But generally, its use is discouraged.  Use put instead.  setplist can only be used with symbols, not other object types.

 -- Function: get object property &optional default
     This function finds the value of the property named PROPERTY in OBJECT's property list.  If there is no such property, default (which itself defaults to nil) is returned.

     PROPERTY is compared with the existing properties using eq, so any object is a legitimate property.

     See put for an example.

 -- Function: put object property value
     This function puts VALUE onto OBJECT's property list under the property name PROPERTY, replacing any previous property value. The put function returns VALUE.

          (put 'fly 'verb 'transitive)
               =>'transitive
          (put 'fly 'noun '(a buzzing little bug))
               => (a buzzing little bug)
          (get 'fly 'verb)
               => transitive
          (object-plist 'fly)
               => (verb transitive noun (a buzzing little bug))

 -- Function: remprop object property
     This function removes the entry for PROPERTY from the property list of OBJECT.  It returns t if the property was indeed found and removed, or nil if there was no such property. (This function was probably omitted from Emacs originally because, since get did not allow a DEFAULT, it was very difficult to distinguish between a missing property and a property whose value was nil; thus, setting a property to nil was close enough to remprop for most purposes.)

Property Lists Not Associated with Objects
------------------------------------------

These functions are useful for manipulating property lists that are stored in places other than symbols:

 -- Function: getf plist property &optional default
     This returns the value of the PROPERTY property stored in the property list PLIST.  For example,

          (getf '(foo 4) 'foo)
               => 4

 -- Macro: putf plist property value
     This stores VALUE as the value of the PROPERTY property in the property list PLIST.  It may modify PLIST destructively, or it may construct a new list structure without altering the old.  The function returns the modified property list, so you can store that back in the place where you got PLIST.  For example,

          (setq my-plist '(bar t foo 4))
               => (bar t foo 4)
          (setq my-plist (putf my-plist 'foo 69))
               => (bar t foo 69)
          (setq my-plist (putf my-plist 'quux '(a)))
               => (quux (a) bar t foo 5)

 -- Function: plists-eq a b
     This function returns non-nil if property lists A and B are eq.  This means that the property lists have the same values for all the same properties, where comparison between values is done using eq.

 -- Function: plists-equal a b
     This function returns non-nil if property lists A and B are equal.

Both of the above functions do order-insensitive comparisons.

     (plists-eq '(a 1 b 2 c nil) '(b 2 a 1))
          => t
     (plists-eq '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello"))
          => nil
     (plists-equal '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello"))
          => t