Why is function defined by defun not bound

Question

intro

Sometimes I want to generate a function programmatically as opposed to defining one with defun. You may wondering why I'd want to do this. Well, it's complicated but just bear with me for a moment.

(defun void-defun (fn)
  (let ((name (gensym "void-defun-")))
    (eval
     `(progn
        (message "Created function: %S" name)
        (defun ,name ()
          (funcall #',fn))))
    name))

problem

When I test whether the function is bound with the following code, all is well.

(let ((fn (void-defun (lambda () 2))))
  (and (fboundp fn) (= 2 (funcall fn)) fn))
;; => void-defun-69

after the test

However, after evaluating this test code and calling the function (whose name I know from the *messages* buffer) I get a void-function error. I expected the function to be bound as indicated by my test. It is as if the function was bound temporarily for the execution of my test form then unbound again.

;; This 69 is just as an example of a name I could get.
(funcall #'void-defun-69)
;; => eval: Symbol’s function definition is void: void-defun-69

question

Why does this happen? And how can I avoid this?

Answer 1

If you assign a function to an uninterned symbol, then naturally you won't find that function on the interned symbol of that name -- they are two completely independent objects.

Your void-defun is returning that uninterned symbol, and in your successful test you are capturing that symbol, so naturally you can successfully call its function.

In your unsuccessful test you are trying to use the function of the interned symbol by that name.

You may be looking for the intern function to obtain the interned symbol by the supplied name.

See also: C-hig (elisp)Creating Symbols