Lexical capture/access local scope in function, the same way as lambda

Question

I'd like to use a function reference in place of a lambda, however the lambda in question captures a lot of locally scoped vars declared in an enclosing let.

For example:

(let ((x 1)(y 2)(z 3)
      (l '(1 2 3 4 5 6 7 8 9)))
  (mapcar (lambda (i) (list x y z i)) l))

Let's assume the entire thing is way more complex, but is similar in essence. I'd want to move the lambda out to a defun, like this.

(defun fn (i)
  "Function to use I in context."
  (list x y z i))

(let ((x 1)(y 2)(z 3)
      (l '(1 2 3 4 5 6 7 8 9)))
  (mapcar 'fn l))

This doesn't work, x y z are void (of course.)

Is there a way to make this possible? (Assume Emacs versions which allow lexical scope.)

Answer 1

Use flet:

(let ((x 1)(y 2)(z 3)
      (l '(1 2 3 4 5 6 7 8 9)))
  (flet ((fn (i)
             (list x y z i)))
    (mapcar #'fn l)))

Answer 2

Ok, so the answers I'm looking for are along the lines of "is this possible", i.e. can scope state be shared to a function arbitrarily.

These two cover the topic effectively.

• https://emacs.stackexchange.com/a/28304/2485
• https://stackoverflow.com/questions/31630226/emacs-lisp-pass-lexical-scope-as-to-a-function

The fact that the internal structure of a closure is "exposed" to the rest of the Lisp world is considered an internal implementation detail. For this reason, we recommend against directly examining or altering the structure of closure objects.

Effectively, the answer is NO, it can't be done (and this goes for relying on internal implementation details in general). The state in use by the lambda in this case, needs to be passed via a conventional method, i.e. parameters, a list structure, etc.