— Function: symbol-function symbol

This returns the object in the function cell of symbol. If the symbol's function cell is void, a void-function error is signaled.

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
     

— Function: fboundp symbol

This function returns t if the symbol has an object in its function cell, nil otherwise. It does not check that the object is a legitimate function.

— Function: fmakunbound symbol

This function makes symbol's function cell void, so that a subsequent attempt to access this cell will cause a void-function error. It returns symbol. (See also makunbound, in Void Variables.)

          (defun foo (x) x)
               ⇒ foo
          (foo 1)
               ⇒1
          (fmakunbound 'foo)
               ⇒ foo
          (foo 1)
          error--> Symbol's function definition is void: foo
     

— Function: fset symbol definition

This function stores definition in the function cell of symbol. The result is definition. Normally definition should be a function or the name of a function, but this is not checked. The argument symbol is an ordinary evaluated argument.

There are three normal uses of this function:

• Copying one symbol's function definition to another—in other words, making an alternate name for a function. (If you think of this as the definition of the new name, you should use defalias instead of fset; see Definition of defalias.)
• Giving a symbol a function definition that is not a list and therefore cannot be made with defun. For example, you can use fset to give a symbol s1 a function definition which is another symbol s2; then s1 serves as an alias for whatever definition s2 presently has. (Once again use defalias instead of fset if you think of this as the definition of s1.)
• In constructs for defining or altering functions. If defun were not a primitive, it could be written in Lisp (as a macro) using fset.

Here are examples of these uses:

          ;; Save foo's definition in old-foo.
          (fset 'old-foo (symbol-function 'foo))
          
          ;; Make the symbol car the function definition of xfirst.
          ;; (Most likely, defalias would be better than fset here.)
          (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"
          
          ;; Here is a function that alters other functions.
          (defun copy-function-definition (new old)
            "Define NEW with the same function definition as OLD."
            (fset new (symbol-function old)))