Макрос Лиспа (или функция) для вложенных циклов

Вам не нужны кавычки, поскольку размеры и переменные в любом случае должны быть известны во время компиляции.

(defmacro nested-loops (dimensions variables &body body)
  (loop for range in (reverse dimensions)
        for index in (reverse variables)
        for x = body then (list y)
        for y = `(loop for ,index from 0 to ,range do ,@x)
        finally (return y)))

Редактировать:

Если размеры не могут быть определены во время компиляции, нам понадобится функция

(defun nested-map (fn dimensions)
  (labels ((gn (args dimensions)
             (if dimensions
               (loop for i from 0 to (car dimensions) do
                 (gn (cons i args) (cdr dimensions)))
               (apply fn (reverse args)))))
    (gn nil dimensions)))

и оборачивать тело в лямбду при вызове.

CL-USER> (nested-map (lambda (&rest indexes) (print indexes)) '(2 3 4))

(0 0 0) 
(0 0 1) 
(0 0 2) 
(0 0 3) 
(0 0 4) 
(0 1 0) 
(0 1 1) 
(0 1 2) 
(0 1 3) 
(0 1 4) 
(0 2 0) 
(0 2 1) 
...

Редактировать (2012-04-16):

Вышеупомянутая версия вложенной карты была написана, чтобы более точно отразить исходную постановку задачи. Как mmj сказал в комментариях, вероятно, более естественно сделать индекс диапазоном от 0 до n-1, и перемещение реверсирования из внутреннего цикла должно повысить эффективность, если мы не настаиваем на порядке итераций по строкам. Кроме того, вероятно, более разумно, чтобы входная функция принимала кортеж вместо отдельных индексов, чтобы быть независимой от ранга. Вот новая версия с заявленными изменениями:

(defun nested-map (fn dimensions)
  (labels ((gn (args dimensions)
             (if dimensions
               (loop for i below (car dimensions) do
                 (gn (cons i args) (cdr dimensions)))
               (funcall fn args))))
    (gn nil (reverse dimensions))))

Потом,

CL-USER> (nested-map #'print '(2 3 4))

Иногда полезным подходом является написание рекурсивного макроса, т. е. макроса, который генерирует код, содержащий другой вызов того же макроса, если только случай не достаточно прост, чтобы его можно было решить напрямую:

(defmacro nested-loops (max-values vars &rest body)
  (if vars
      `(loop for ,(first vars) from 0 to ,(first max-values) do
          (nested-loops ,(rest max-values) ,(rest vars) ,@body))
      `(progn ,@body)))

(nested-loops (2 3 4) (i j k)
  (print (list i j k)))

В приведенном выше примере, если список переменных пуст, макрос расширяется непосредственно до форм тела, в противном случае сгенерированный код представляет собой (loop...) для первой переменной, содержащей еще один вызов (nested-loops ...) в части выполнения.

Макрос не является рекурсивным в обычном смысле, используемом для функций (он не вызывает сам себя напрямую), но логика макрорасширения будет вызывать тот же макрос для внутренних частей, пока генерация кода не будет завершена.

Обратите внимание, что формы максимального значения, используемые во внутренних циклах, будут переоцениваться на каждой итерации внешнего цикла. Не имеет значения, если формы действительно являются числами, как в вашем тестовом примере, но другое дело, если они, например, являются вызовами функций.

Хм. Вот пример такого макроса в Common Lisp. Обратите внимание, однако, что я не уверен, что это действительно хорошая идея. Но мы все здесь взрослые люди, не так ли?

(defmacro nested-loop (control &body body)
  (let ((variables ())
        (lower-bounds ())
        (upper-bounds ()))
    (loop
       :for ctl :in (reverse control)
       :do (destructuring-bind (variable bound1 &optional (bound2 nil got-bound2)) ctl
             (push variable variables)
             (push (if got-bound2 bound1 0) lower-bounds)
             (push (if got-bound2 bound2 bound1) upper-bounds)))
    (labels ((recurr (vars lowers uppers)
               (if (null vars)
                   `(progn ,@body)
                   `(loop 
                       :for ,(car vars) :upfrom ,(car lowers) :to ,(car uppers)
                       :do ,(recurr (cdr vars) (cdr lowers) (cdr uppers))))))
      (recurr variables lower-bounds upper-bounds))))

Синтаксис немного отличается от вашего предложения.

(nested-loop ((i 0 10) (j 15) (k 15 20)) 
    (format t "~D ~D ~D~%" i j k))

расширяется в

(loop :for i :upfrom 0 :to 10
  :do (loop :for j :upfrom 0 :to 15
            :do (loop :for k :upfrom 15 :to 20
                      :do (progn (format t "~d ~d ~d~%" i j k)))))

Первым аргументом макроса является список списка вида

(variable upper-bound)

(с подразумеваемой нижней границей 0) или

(variable lower-bound upper-bounds)

Приложив немного больше любви, можно было бы даже получить что-то вроде

(nested-loop ((i :upfrom 10 :below 20) (j :downfrom 100 :to 1)) ...)

но тогда зачем беспокоиться, если loop уже имеет все эти функции?