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

Question

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

;; 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？

Answer 1

在已经非常复杂的宏中存在许多基本问题（例如应生成什么代码以及何时生成）。您可能会考虑先做更简单的宏示例。但是，也许可以使您的代码正常工作，所以不会丢失所有代码。

让我们看一些问题：

如何在代码中使用宏

您想像这样使用宏：

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