是“透明”的宏可以吗？

Question

我想编写一个 Clojure with-test-tags 宏来包装一堆表单，并向每个 deftest 表单的名称添加一些元数据 - 具体来说，添加一些东西到 :tags 键，这样我就可以使用工具来运行带有特定标签的测试。

with-test-tags 的一个明显实现是递归地遍历整个主体，修改我找到的每个 deftest 表单。但我最近读过Let Over Lambda，他提出了一个很好的观点：不用自己遍历代码，只需将代码包装在macrolet中，然后让编译器为你走走。类似这样：

(defmacro with-test-tags [tags & body]
  `(macrolet [(~'deftest [name# & more#]
                `(~'~'deftest ~(vary-meta name# update-in [:tags] (fnil into []) ~tags)
                   ~@more#))]
     (do ~@body)))

(with-test-tags [:a :b] 
  (deftest x (...do tests...)))

但这有一个明显的问题，即 deftest 宏继续递归地永远扩展。我可以将其扩展为 clojure.test/deftest ，从而避免任何进一步的递归扩展，但随后我无法将 with-test-tags 的实例嵌套到标记测试子组。

在这一点上，特别是对于像 deftest 这样简单的事情，看起来我自己编写代码会更简单。但我想知道是否有人知道编写宏的技术，该技术“稍微修改”某些子表达式，而不会永远递归。

出于好奇：我考虑了一些其他方法，例如在代码中上下移动时设置一个编译时可绑定的变量，并在我最终看到 < code>deftest，但由于每个宏仅返回一个扩展，因此下一次调用 Macroexpand 时其绑定将不会就位。

编辑

我刚刚完成了 postwalk 实现，虽然它有效，但它不尊重特殊形式，例如 quote - 它也会在这些形式内部扩展。

(defmacro with-test-tags [tags & body]
  (cons `do
        (postwalk (fn [form]
                    (if (and (seq? form)
                             (symbol? (first form))
                             (= "deftest" (name (first form))))
                      (seq (update-in (vec form) [1]
                                      vary-meta update-in [:tags] (fnil into []) tags))
                      form))
                  body)))

（另外，对于 common-lisp 标签上可能出现的噪音，我深表歉意——我认为即使你的 Clojure 经验很少，你也可以帮助解决更奇怪的宏问题。）

Answer 1

（这是一种新方法，eval- 和 bounding-free。正如中讨论的
对此答案的评论，使用 eval 是有问题的，因为
它阻止测试关闭它们看起来的词汇环境
定义在 (so (let [x 1] (deftest easy (is (= x 1)))) 否
更长的作品）。我将原来的方法留在了下半部分
答案，位于水平规则下方。）

macrolet 方法

实现

使用 Clojure 1.3.0-beta2 测试的 ；它可能应该与 1.2.x 一起工作
出色地。

(ns deftest-magic.core
  (:use [clojure.tools.macro :only [macrolet]]))

(defmacro with-test-tags [tags & body]
  (let [deftest-decl
        (list 'deftest ['name '& 'body]
              (list 'let ['n `(vary-meta ~'name update-in [:tags]
                                         (fnil into #{}) ~tags)
                          'form `(list* '~'clojure.test/deftest ~'n ~'body)]
                    'form))
        with-test-tags-decl
        (list 'with-test-tags ['tags '& 'body]
              `(list* '~'deftest-magic.core/with-test-tags
                      (into ~tags ~'tags) ~'body))]
    `(macrolet [~deftest-decl
                ~with-test-tags-decl]
       ~@body)))

用法

...最好通过一套（通过）测试来演示：

(ns deftest-magic.test.core
  (:use [deftest-magic.core :only [with-test-tags]])
  (:use clojure.test))

;; defines a test with no tags attached:
(deftest plain-deftest
  (is (= :foo :foo)))

(with-test-tags #{:foo}

  ;; this test will be tagged #{:foo}:
  (deftest foo
    (is true))

  (with-test-tags #{:bar}

    ;; this test will be tagged #{:foo :bar}:
    (deftest foo-bar
      (is true))))

;; confirming the claims made in the comments above:
(deftest test-tags
  (let [plaintest-tags (:tags (meta #'plain-deftest))]
    (is (or (nil? plaintest-tags) (empty? plaintest-tags))))
  (is (= #{:foo} (:tags (meta #'foo))))
  (is (= #{:foo :bar} (:tags (meta #'foo-bar)))))

;; tests can be closures:
(let [x 1]
  (deftest lexical-bindings-no-tags
    (is (= x 1))))

;; this works inside with-test-args as well:
(with-test-tags #{:foo}
  (let [x 1]
    (deftest easy (is true))
    (deftest lexical-bindings-with-tags
      (is (= #{:foo} (:tags (meta #'easy))))
      (is (= x 1)))))

设计说明：

1. 我们希望进行基于 macrolet 的设计，如
   问题文本工作。我们关心是否能够筑巢
   with-test-tags 并保留定义测试的可能性
   他们的身体接近他们所定义的词汇环境

2. 我们将 macroletting deftest 扩展为
   clojure.test/deftest 表单，附加适当的元数据
   测试的名称。这里重要的部分是 with-test-tags
   将适当的标签集注入到定义中
   macrolet 表单内自定义本地 deftest；一旦
   编译器开始扩展 deftest 形式，标签集
   将被硬连线到代码中。

3. 如果我们就这样，在嵌套的内部定义测试
   with-test-tags 只会使用传递给的标签进行标记
   最里面的 with-test-tags 形式。因此我们也有 with-test-tags
macrolet 符号 with-test-tags 本身的行为很像
   本地 deftest：它扩展为对顶层的调用
   with-test-tags 宏，将适当的标签注入到
   taget。

4. 其目的是内部 with-test-tags 形式

   (with-test-tags #{:foo}
     （带有测试标签#{:bar}
       ...））
   

   扩展为(deftest-magic.core/with-test-tags #{:foo :bar} ...)
   （如果确实 deftest-magic.core 是命名空间 with-test-tags
   定义于）。这种形式立即扩展为熟悉的形式
   macrolet 形式，带有 deftest 和 with-test-tags 符号
   本地绑定到宏，并在内部硬连线正确的标签集

---

（原始答案更新了一些设计注释，一些
重新措辞和重新格式化等。代码未更改。）

绑定 + eval 方法。

（另请参阅 https://gist.github.com/1185513 了解版本
另外使用macrolet来避免自定义顶级
deftest.)

实现

以下内容经过测试可与 Clojure 1.3.0-beta2 配合使用；与
^:dynamic 部分已删除，它应该适用于 1.2：

(ns deftest-magic.core)

(def ^:dynamic *tags* #{})

(defmacro with-test-tags [tags & body]
  `(binding [*tags* (into *tags* ~tags)]
     ~@body))

(defmacro deftest [name & body]
  `(let [n# (vary-meta '~name update-in [:tags] (fnil into #{}) *tags*)
         form# (list* 'clojure.test/deftest n# '~body)]
     (eval form#)))

使用

(ns example.core
  (:use [clojure.test :exclude [deftest]])
  (:use [deftest-magic.core :only [with-test-tags deftest]]))

;; defines a test with an empty set of tags:
(deftest no-tags
  (is true))

(with-test-tags #{:foo}

  ;; this test will be tagged #{:foo}:
  (deftest foo
    (is true))

  (with-test-tags #{:bar}

    ;; this test will be tagged #{:foo :bar}:
    (deftest foo-bar
      (is true))))

设计说明

我认为在这种情况下，明智地使用 eval 会导致
有用的解决方案。基本设计（基于“bounding-able Var”）
idea) 具有三个组件：

1. 可动态绑定的 Var -- *tags* -- 在编译时绑定
   deftest 表单使用一组标签来装饰的时间
   正在定义测试。我们默认不添加标签，所以它的初始值
   值为 #{}。

2. 一个 with-test-tags 宏，它安装了适当的
   *tags*.

3. 自定义 deftest 宏，可扩展为类似于 let 的形式
   这（以下是扩展，稍微简化为
   清晰度）：

   (let [n (vary-meta ' update-in [:tags] (fnil into #{}) *tags*)
         形式（列表*'clojure.test/deftest n'）]
     （评估表））
   

   和 是赋予自定义的参数
   deftest，通过取消引用插入到适当的位置
   语法引用扩展模板的适当部分。

因此，自定义 deftest 的扩展是一个 let 形式，其中，
首先，通过装饰给定的来准备新测试的名称
带有 :tags 元数据的符号；然后是一个 clojure.test/deftest 表单
使用这个修饰名来构造；最后是后一种形式
被交给eval。

这里的关键点是这里的 (eval form) 表达式是
每当它们包含的命名空间是 AOT 编译的或
在运行此的 JVM 的生命周期中第一次需要
代码。这与 a 中的 (println "asdf") 完全相同
顶级 (def asdf (println "asdf"))，它将打印 asdf
每当命名空间是 AOT 编译的或第一次需要时
时间；事实上，顶级 (println "asdf") 的作用类似。

这是通过注意 Clojure 中的编译来解释的：
对所有顶级表格的评估。在(绑定[...](deftest ...)中，
binding 是顶级表单，但仅在 deftest 时返回
确实如此，并且我们的自定义 deftest 扩展为一个表单，当
eval 确实如此。 （另一方面，require执行顶层的方式
已经编译的命名空间中的代码——这样如果你有 (def t
(System/currentTimeMillis)) 在您的代码中，t 的值将
取决于您何时需要名称空间，而不是何时需要名称空间
已编译，可以通过试验 AOT 编译的代码来确定
——这就是 Clojure 的工作方式。如果你想要实际的，请使用 read-eval
嵌入代码中的常量。）

实际上，自定义 deftest 运行编译器（通过 eval）
宏扩展的编译时运行时。乐趣。

最后，当将 deftest 表单放入 with-test-tags 表单中时，
(eval form) 的 form 将已使用绑定准备好
通过 with-test-tags 安装到位。因此测试被定义
将用适当的标签集进行装饰。

在 REPL

user=> (use 'deftest-magic.core '[clojure.test :exclude [deftest]])
nil
user=> (with-test-tags #{:foo}
         (deftest foo (is true))
         (with-test-tags #{:bar}
           (deftest foo-bar (is true))))
#'user/foo-bar
user=> (meta #'foo)
{:ns #<Namespace user>,
 :name foo,
 :file "NO_SOURCE_PATH",
 :line 2,
 :test #<user$fn__90 user$fn__90@50903025>,
 :tags #{:foo}}                                         ; <= note the tags
user=> (meta #'foo-bar)
{:ns #<Namespace user>,
 :name foo-bar,
 :file "NO_SOURCE_PATH",
 :line 2,
 :test #<user$fn__94 user$fn__94@368b1a4f>,
 :tags #{:foo :bar}}                                    ; <= likewise
user=> (deftest quux (is true))
#'user/quux
user=> (meta #'quux)
{:ns #<Namespace user>,
 :name quux,
 :file "NO_SOURCE_PATH",
 :line 5,
 :test #<user$fn__106 user$fn__106@b7c96a9>,
 :tags #{}}                                             ; <= no tags works too

并且只是为了确保正在定义工作测试......

user=> (run-tests 'user)

Testing user

Ran 3 tests containing 3 assertions.
0 failures, 0 errors.
{:type :summary, :pass 3, :test 3, :error 0, :fail 0}

Answer 2

至少对于 Common Lisp，您只需为隐藏的宏添加别名即可。类似的东西：

(setf (macro-function 'deftest2) (macro-function 'deftest))
(defmacro with-test-tags (etc...)
  `(macrolet ((deftest (etc...)
                 ``(deftest2 ...

Clojure 应该有类似的东西。该主题在这里讨论：定义 Clojure 宏的同义词。请注意，定义扩展为“deftest”调用的“deftest2”宏可能不起作用。

我发现这个答案有点晚了，但我还是把它贴在这里，供路人参考。