idiomatic way to lexically scope variables in a cl-loop body

Question

Here is some asynchronous code in a cl-loop:

;;; foo.el ---                              -*- lexical-binding: t; -*-
(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do (run-at-time 0 nil
                           (lambda () (message "index=%s,value=%s" index value)))))

This code prints "index=3,value=c" 3 times in the *Messages* buffer. This is not what I want. I would like to see "index=0,value=a", "index=1,value=b", "index=2,value=c" (I don't care about the order of messages).

A workaround is to let-bind the index and value variables:

;;; foo.el ---                              -*- lexical-binding: t; -*-
(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do (let ((index index) (value value))
                (run-at-time 0 nil
                             (lambda () (message "index=%s,value=%s" index value))))))

This is good enough for me but I thought there might be a more elegant solution.

Another workaround is to pass #'message as third argument to run-at-time instead of the lambda and to pass the arguments to message as &rest arguments to run-at-time. This is not good enough for me though because my real code is a bit more complex and involves calling a callback variable which may or may not do a run-at-time.

Answer 1

Your problem is that the timer runs the function when the loop has finished. The lexically bound variables index and value have for all calls the values after the last iteration.

One solution is to evaluate the variables at iteration time and pass just the values as arguments to the function.

(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do (run-at-time 0 nil
                           (lambda (index value) (message "index=%s,value=%s" index value))
               index value)))

With that method you could even free the function from its lexical environment:

(defun my-out (index value)
  (message "index=%s,value=%s" index value))

(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do (run-at-time 0 nil
               #'my-out
               index value)))

Answer 2

Another option is to use backquoting to substitute the values for each loop iteration directly into the lambda form:

;;; foo.el ---                              -*- lexical-binding: t; -*-
(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do (run-at-time 0 nil
                           `(lambda () (message "index=%s,value=%s" ',index ',value)))))

But really, the approach you came up with yourself (i.e. to create lexical variables within each iteration) is probably the way to go.

This is, after all, a case of the classic "how do I create/fake a closure in elisp" question, and the idiomatic answer when lexical-binding is enabled is to use a let binding.

You don't need to repeat the same names for the inner variables, though -- and perhaps you'd find it less inelegant if you weren't doing that?

Answer 3

One way is to create a macro:

(defmacro lexical-save (vars &rest body)
  `(lexical-let ,(mapcar (lambda (var) (list var var)) vars)
     ,@body))

You can use it is follows:

(let ((my-list '(a b c)))
  (cl-loop for index below (length my-list)
           for value = (seq-elt my-list index)
           do
           (run-at-time
            0 nil
            (lexical-save (index value)
                          (lambda () (insert (format "index=%s,value=%s\n" index value)))))))

I altered your example to let it insert text instead of using message, in order to better see what it's doing. Run it in the *scratch* buffer.