7

是否可以编写一个 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 的递归解决方案，非常棒。

4

3 回答 3

8

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

(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）：

上面版本的nested-map 是为了更接近地反映原始问题陈述而编写的。正如 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))
于 2012-04-15T16:09:42.463 回答
7

有时一种有用的方法是编写递归宏，即生成包含同一宏的另一个调用的代码的宏，除非情况足够简单，可以直接解决：

(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 ...)do 部分中的另一个调用。

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

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

于 2012-04-15T19:37:42.397 回答
2

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

于 2012-04-15T16:08:52.447 回答