Question

是否可以编写一个Common Lisp宏来获取维度和变量列表，一个体（迭代），并创建由列表指定的嵌套循环组成的代码？

就是这样：

(nested-loops '(2 5 3) '(i j k) whatever_loop_body)

应该扩展到

(loop for i from 0 below 2 do
  (loop for j from 0 below 5 do
    (loop for k from 0 below 3 do
      whatever_loop_body)))

跟进

正如怀远正确指出的那样，我必须知道在编译时传递给宏的参数。如果您确实需要我的功能，请查看以下内容。

如果你对宏没问题，那就选择6502的递归解决方案，真是太棒了。

Answer 1

您不需要引号，因为无论如何都需要在编译时知道维度和变量。

(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)))

并在调用时将正文包裹在lambda中。

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))

Answer 2

有时一种有用的方法是编写递归宏，即生成包含同一宏的另一个调用的代码的宏，除非案例很简单直接解决：

(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...)，其中包含do部分中的另一个(nested-loops ...)调用。

宏在用于函数的正常意义上不是递归的（它不直接调用自身），但宏扩展逻辑将为内部部分调用相同的宏，直到代码生成完成。

请注意，内循环中使用的最大值表单将在外循环的每次迭代中重新计算。如果表单确实是测试用例中的数字，那么它没有任何区别，但如果它们是例如函数调用则不同。

Answer 3

嗯。这是常见的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已经拥有所有这些功能，为什么还要费心呢？

Lisp宏（或函数）用于嵌套循环

3 个答案:

编辑：

编辑（2012-04-16）：