1

我正在尝试编写一个调试宏来打印出表达式及其值。如果我发送一个惰性序列，这会导致问题，因为如果我把它变成一个字符串（带 str），程序就会挂起。如果它位于顶层，则很容易检测到惰性序列：

(def foo (cycle [1 2]))
(= (type foo) clojure.lang.LazySeq) ;=> true

但是当然，如​​果它嵌套在另一个集合中，这将不起作用

(def bar (list (cycle [1 2])))
(= (type bar) clojure.lang.LazySeq) ;=> false

为了解决这个问题，我需要两件事之一：

1：一个检查集合的函数，看看它是否包含嵌套在某处的惰性序列。

2：将集合转换为字符串而不评估嵌套惰性序列的函数，如下所示：

(str2 {:inf (cycle [1 2])}) => "{:inf #clojure.lang.LazySeq@e9383}"

使用 Michał Marczyk 的回答我想出了这个宏：

(defmacro dbg-print [& rest]
  "Print out values or expressions in context"
  `(let [lazy-take# 5 ;when printing lazy-seq, how many elements to print
         symb-str# (map str '~rest)
         symb-evl# (reverse
                    (binding [*print-length* 10] 
                      (loop [coll# (list ~@rest) retur# '()]
                        (if (not (empty? coll#))
                          (recur (rest coll#) (cons (pr-str (first coll#)) retur#))
                          retur#))))
         pairs# (map #(str %1 %2 %3 %4) symb-str# (repeat ":") symb-evl# (repeat " "))
         str# (reduce str pairs#)]
     (println (format "%s\n" str#))))

它是这样工作的：

(dbg-print (+ 1 3) (cycle [1 2])) ;=> (+ 1 3):4 (cycle [1 2]):(1 2 1 2 1 2 1 2 1 2 ...)

并且可以处理嵌套的惰性序列：

(dbg-print (list (cycle [1 2]))) ;=> (list (cycle [1 2])):((1 2 1 2 1 2 1 2 1 2 ...))
4

2 回答 2

4

您可以使用内置的 Vars和*print-length*/系列函数（包括如果您想将字符串表示形式作为返回值返回，而不是将其打印出来）：*print-level*prprintpr-str

(binding [*print-length* 3
          *print-level*  3]
  (prn ((fn explode []
          (repeatedly #(repeatedly explode))))))

这打印出来

(((# # # ...) (# # # ...) (# # # ...) ...) ((# # # ...) (# # # ...) (# # # ...) ...) ((# # # ...) (# # # ...) (# # # ...) ...) ...)

其中#s 表示数据结构的那些部分由于下降过去*print-level*而被省略， ...s 表示数据结构的那些部分由于延伸过去而被省略*print-length*。

打印了一些实际数据的另外两个示例：

user> (binding [*print-length* 10]
        (prn (cycle [1 2 3])))
(1 2 3 1 2 3 1 2 3 1 ...)

user> (binding [*print-level* 10]
        (prn ((fn step [i]
                (lazy-seq (list i (step (inc i)))))
              0)))
(0 (1 (2 (3 (4 (5 (6 (7 (8 (9 #))))))))))

最后，一个返回字符串的例子：

user> (binding [*print-length* 2
                *print-level*  2]
        (prn-str ((fn explode []
                    (repeatedly #(repeatedly explode))))))
"((# # ...) (# # ...) ...)\n"

此功能记录在相关变量的文档字符串中，请参阅(doc *print-length*)和(doc *print-level*)。

于 2013-06-14T04:18:29.847 回答
3

我想到了几种方法：

  • 使用 prewalk 遍历结构，并用占位符替换惰性序列。
  • 使用 prewalk 遍历序列，并递归地将 take 10 应用于每个集合。
  • 扩展 Clojure.lang.LazySeq 的 print-method multi 方法，以根据您的选择打印它们。
于 2013-06-13T15:39:22.097 回答