The function definition of a symbol is the object stored in the function cell of the symbol. The functions described here access, test, and set the function cell of symbols.
See also the function
indirect-function in Function Indirection.
This returns the object in the function cell of symbol. If the
symbol’s function cell is void, a
void-function error is
This function does not check that the returned object is a legitimate function.
(defun bar (n) (+ n 2)) ⇒ bar
(symbol-function 'bar) ⇒ (lambda (n) (+ n 2))
(fset 'baz 'bar) ⇒ bar
(symbol-function 'baz) ⇒ bar
If you have never given a symbol any function definition, we say that
that symbol’s function cell is void. In other words, the function
cell does not have any Lisp object in it. If you try to call such a symbol
as a function, it signals a
Note that void is not the same as
nil or the symbol
void. The symbols
void are Lisp objects,
and can be stored into a function cell just as any other object can be
(and they can be valid functions if you define them in turn with
defun). A void function cell contains no object whatsoever.
You can test the voidness of a symbol’s function definition with
fboundp. After you have given a symbol a function definition, you
can make it void once more using
This function returns
t if symbol has an object in its
nil otherwise. It does not check that the object
is a legitimate function.
This function makes symbol’s function cell void, so that a
subsequent attempt to access this cell will cause a
error. (See also
makunbound, in Local Variables.)
(defun foo (x) x) ⇒ x
(foo 1) ⇒1
(fmakunbound 'foo) ⇒ x
(foo 1) error→ Symbol's function definition is void: foo
This function stores object in the function cell of symbol. The result is object. Normally object should be a function or the name of a function, but this is not checked.
There are three normal uses of this function:
defun. For example, you can use
fsetto give a symbol symbol1 a function definition which is another symbol symbol2; then symbol1 serves as an alias for whatever definition symbol2 presently has.
defunwere not a primitive, it could be written in Lisp (as a macro) using
Here are examples of the first two uses:
firstthe same definition
carhas. (fset 'first (symbol-function 'car)) ⇒ #<subr car>
(first '(1 2 3)) ⇒ 1
;; Make the symbol
carthe function definition of
xfirst. (fset 'xfirst 'car) ⇒ car
(xfirst '(1 2 3)) ⇒ 1
(symbol-function 'xfirst) ⇒ car
(symbol-function (symbol-function 'xfirst)) ⇒ #<subr car>
;; Define a named keyboard macro. (fset 'kill-two-lines "\^u2\^k") ⇒ "\^u2\^k"
See also the related functions
defalias, in Defining Functions.
When writing a function that extends a previously defined function, the following idiom is sometimes used:
(fset 'old-foo (symbol-function 'foo)) (defun foo () "Just like old-foo, except more so."
This does not work properly if
foo has been defined to autoload.
In such a case, when
old-foo, Lisp attempts
old-foo by loading a file. Since this presumably
foo rather than
old-foo, it does not produce the
proper results. The only way to avoid this problem is to make sure the
file is loaded before moving aside the old definition of
But it is unmodular and unclean, in any case, for a Lisp file to redefine a function defined elsewhere.