Higher-order functions in Elisp

Question

I created a function that returns a function in Elisp:

(defun singleton-set (elem)
  (defun f (n) (= n elem))
  f)

I try to run this in IELM, and it fails:

ELISP> (singleton-set 5)
*** Eval error ***  Symbol's value as variable is void: f
ELISP> ((singleton-set 5) 5)
*** Eval error ***  Invalid function: (singleton-set 5)

Due to What is the difference between Lisp-1 and Lisp-2? i changed the code to

(defun singleton-set (elem)
  (defun f (n) (= n elem))
  #'f)

And invocation to (funcall (singleton-set 5) 5), but now the error is

*** Eval error *** Symbol's value as variable is void: elem

I understand from elisp: capturing variable from inner function that this is due to dynamic binding of Emacs Lisp.

How to make functions returning functions possible in Emacs Lisp? What is the reason this mechanism is different from other languages like Python, Scala or Clojure?

Related questions:

• elisp functions as parameters and as return value
• Elisp interactive function name
• How to Create a Temporary Function in Emacs Lisp
• In elisp, how do I put a function in a variable?

Answer 1

(defun singleton-set (elem)
  `(lambda (n) (= n ,elem))

See: elisp functions as parameters and as return value

Answer 2

From the NEWS for Emacs 24:

Lisp changes in Emacs 24.1

• Code can now use lexical scoping by default instead of dynamic scoping. The lexical-binding variable enables lexical scoping for local variables. It is typically set via a file-local variable in the first line of the file, in which case it applies to all the code in that file.

So, in Emacs 24:

(setq lexical-binding t)
(defun singleton-set (elem) (lambda (n) (= n elem)))
(mapcar (singleton-set 1) '(0 1 2 3))
    ===> (nil t nil nil)

Answer 3

How to make functions returning functions possible in Emacs Lisp?

Using fake closures, and lexical-let.

What is the reason this mechanism is different from other languages like Python, Scala or Clojure?

Richard Stallman answered this question in a paper he wrote a while ago.