Nrthugu

I have a macro that intends to creates a closure:

; -*- lexical-binding: t -*-

(defmacro repro ()

  (let ((kmap-sym (gensym "kmap-")))

    `(let ((,kmap-sym (make-sparse-keymap)))

       (define-key ,kmap-sym "a"

         (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))

       ,kmap-sym)))



;; only works when lexical-binding: t in the current file

(funcall (lookup-key (repro) "a"))

Although lexical-binding is t in the file where the macro is defined, (funcall (lookup-key (repro) "a")) fails with the error (void-variable kmap-30252) whenever it is evaluated in a different file where lexical-binding is nil.

Since I can't control where the macro will be used, I considered going back to using lexical-let for the inner let in the example, which does work regardless of where the macro is invoked.

(defmacro repro ()

  (let ((kmap-sym (gensym "kmap-")))

    `(lexical-let ((,kmap-sym (make-sparse-keymap)))

       (define-key ,kmap-sym "a"

         (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))

       ,kmap-sym)))



;; this works in any file

(funcall (lookup-key (repro) "a"))

But lexical-let requires cl, which I would like to avoid, and unfortunately lexical-let is not defined in cl-lib.

What options do I have for creating a closure?

Should the macroexpansion of repro always expand into lexical bindings given that lexical-binding is t where the macro is defined?

Not very sure if the result meets your expectation.

(defun foo (keymap)

  `(lambda () (interactive) (message "kmap is %s" ',keymap)))



(defmacro repro ()

  (let ((kmap-sym (gensym "kmap-")))

    `(let ((,kmap-sym (make-sparse-keymap)))

       (define-key ,kmap-sym "a"

         (foo ,kmap-sym))

       ,kmap-sym)))



(setq lexical-binding nil)

;; => nil



(funcall (lookup-key (repro) "a"))

;; => "kmap is (keymap (97 lambda nil (interactive) (message kmap is %s (quote #0))))"



(setq lexical-binding t)

;; => t



(funcall (lookup-key (repro) "a"))

;; => "kmap is (keymap (97 lambda nil (interactive) (message kmap is %s (quote #0))))"

The following does the same without using a top-level defun.

(defmacro repro ()

  (let ((kmap-sym (gensym "kmap-"))

        (fun (lambda (keymap)

               `(lambda () (interactive) (message "kmap is %s" ',keymap)))))

    `(let ((,kmap-sym (make-sparse-keymap)))

       (define-key ,kmap-sym "a"

         (,fun ,kmap-sym))

       ,kmap-sym)))

There is an ugly workaround using eval with the optional argument LEXICAL set to t.

(defmacro repro ()

  (let ((kmap-sym (gensym "kmap-")))

    `(eval

      '(let ((,kmap-sym (make-sparse-keymap)))

         (define-key ,kmap-sym "a"

           (lambda () (interactive) (message "kmap is %s" ,kmap-sym)))

         ,kmap-sym)

      t)))

It is ugly since the associated quoting prevents byte-compilation.

Your example is likely not representative of the actual code you're using, but a good solution might be to create the closure in the macro and return the closure, instead of returning code which may or may not turn into a closure depending on lexical-binding:

(defmacro repro ()

  (let* ((kmap-sym (gensym "kmap-")))

    `(let ((,kmap-sym (make-sparse-keymap)))

       (define-key ,kmap-sym "a"

          ',(lambda () (interactive) (message "kmap is %S" (symbol-value kmap-sym))))

       ,kmap-sym)))

The other option I use nowadays is to do something like

(defmacro ...

  (if (not lexical-binding)

      (error "Macro `foo` can't be used with dynamic binding"))

    ...))

the variable lexical-binding can be relied upon (while expanding the macro) to indicate whether the returned code will be run with lexical or dynamic binding.