Macros 如何在不使用“eval”的情况下编写此宏？

我试图编写一个宏，创建任意数量的嵌套循环，并在循环的每次迭代中执行一些代码。在我的第一次尝试中（如下所示），宏返回了代码，而不是运行它

;; WRONG! Returns a bunch of nested loops instead of evaluating the code.

(defmacro do-combinations ((var lists) &body body)
  `(let* ((lst (mapcar #'(lambda (x)
                           `(loop for ,(gensym) in (list ,@x) do))
                       ,lists))
          (symbols (mapcar #'caddr lst)))
     (reduce #'(lambda (x y) `(,@y ,x))
             lst
             :initial-value `(let ((,',var (list ,@symbols)))
                               (progn ,',@body)))))
CL-USER 25 : 1 > (do-combinations (n '((1 2 3)
                                       (10 20 30)
                                       (100 200 300)))
                   (pprint n))
(LOOP FOR #:G872 IN (LIST 100 200 300)
      DO (LOOP FOR #:G871 IN (LIST 10 20 30)
               DO (LOOP FOR #:G870 IN (LIST 1 2 3)
                        DO (LET # #))))

我最后的补救办法是插入一个

eval

;; Ugly fix with eval
(defmacro do-combinations ((var lists) &body body)
  `(let* ((lst (mapcar #'(lambda (x)
                           `(loop for ,(gensym) in (list ,@x) do))
                       ,lists))
          (symbols (mapcar #'caddr lst)))
     (eval (reduce #'(lambda (x y) `(,@y ,x))
                   lst
                   :initial-value `(let ((,',var (list ,@symbols)))
                                     (progn ,',@body))))))    

CL-USER 35 : 1 > (do-combinations (n '((1 2 3)
                                       (10 20 30)
                                       (100 200 300)))
                   (pprint n))

(1 10 100)
(2 10 100)
...

---

修复确实有效（有点），但看起来很糟糕。如何在不使用

eval

的情况下更优雅地编写此宏？

在一个已经相当复杂的宏中，有一系列基本问题（如应该生成什么代码以及何时生成代码）。您可以先考虑做一些更简单的宏示例。 但是你可以让你的代码正常工作，所以不是所有的都丢失了

让我们来看一些问题：

如何在代码中使用宏

您希望像这样使用宏：

(do-combinations (n '((1 2 3)
                      (10 20 30)
                      (100 200 300)))
  (pprint n))

但是引用嵌套列表是没有意义的。宏可能在编译时生成代码，此时需要知道列表。因此，您无法或不应该对此进行评估。因此，可以删除以下引用：

(do-combinations (n ((1 2 3)
                     (10 20 30)
                     (100 200 300)))
  (pprint n))

一些宏观基础知识

现在，在编写宏时，需要了解以下基本内容：

• 宏将生成代码。您需要知道宏应该生成什么代码。写下代码，并将其与宏的功能进行比较
• 要查看宏生成的内容，请使用

  macroexpand

  和

  macroexpand-1

  。使用

  pprint

  漂亮地打印生成的代码

让我们看看正在生成的代码

现在让我们看看宏生成的代码：

CL-USER 145 > (pprint
               (macroexpand-1 '(do-combinations (n ((1 2 3)
                                                    (10 20 30)
                                                    (100 200 300)))
                                 (pprint n))))

(LET* ((LST
        (MAPCAR #'(LAMBDA (X) `(LOOP FOR ,(GENSYM) IN (LIST ,@X) DO))
                ((1 2 3) (10 20 30) (100 200 300))))
       (SYMBOLS (MAPCAR #'CADDR LST)))
  (REDUCE #'(LAMBDA (X Y) `(,@Y ,X))
          LST
          :INITIAL-VALUE
          `(LET ((N (LIST ,@SYMBOLS))) (PROGN (PPRINT N)))))

您可以看到这一切都是错误的，因为生成的大量代码应该在宏扩展时运行，而不是在运行时运行！它根本不会生成嵌套循环

您可以在宏中看到第二行：

`(let* ((lst (mapcar #'(lambda (x)

这意味着将生成代码。但您可能希望在扩展阶段运行它

更好的版本

以下是具有正确代码生成的版本：

(defmacro do-combinations ((var lists) &body body)
  (let* ((lst (mapcar #'(lambda (x)
                           `(loop for ,(gensym) in (list ,@x) do))
                       lists))
         (symbols (mapcar #'caddr lst)))
     (reduce #'(lambda (x y) `(,@y ,x))
             lst
             :initial-value `(let ((,var (list ,@symbols)))
                               ,@body))))

让我们看看：

CL-USER 147 > (pprint
               (macroexpand-1 '(do-combinations (n ((1 2 3)
                                                    (10 20 30)
                                                    (100 200 300)))
                                 (pprint n))))

(LOOP FOR #:G424120 IN (LIST 100 200 300)
      DO (LOOP FOR #:G424119 IN (LIST 10 20 30)
               DO (LOOP FOR #:G424118 IN (LIST 1 2 3)
                        DO (LET ((N (LIST #:G424118 #:G424119 #:G424120)))
                             (PPRINT N)))))

---

这是某种练习，还是您真的只需要

alexandria:map product

？如果您在LispWorks中看到类似“CL-USER 35:1>”的提示，则表示您处于错误中断循环中。输入

：top

可以让您摆脱困境。通常使用它是没有意义的——它是为了在发生错误时进行调试。@Svante，我只是觉得用宏嵌套循环会很酷。宏的要点是运行所有组合，而不存储太多中间值，如

alexandria:map product

Wild.@Paulomedes:OK，但这样的宏需要知道在宏展开时嵌套循环的数量，因此它基本上只能使用常量。