Question

我有一个漫长而懒惰的序列，我想减少并懒惰地测试。一旦两个连续元素彼此不是=（或其他一些谓词），我想停止使用生产成本昂贵的列表。是的，这听起来像take-while，但请进一步阅读。

我想写一些简单而优雅的东西（假装every?像reduce那样工作一分钟）：

(every? = (range 100000000))

但这并不是懒散的，所以它挂在无限的seqs上。我发现这几乎是我想要的：

(apply = (range 100000000))

但是，我注意到序列分块导致创建和测试额外的，不必要的元素。至少，这就是我认为这是在下面的代码中发生的事情：

;; Displays chunking behavior in groups of four on my system and prints 1 2 3 4
(apply = (map #(do (println %) %) (iterate inc 1)))

;; This prints 0 to 31
(apply = (map #(do (println %) %) (range)))

我找到了使用take-while和count来解决所采用元素数量的变通方法，但这很麻烦。

我是否应该礼貌地向Rich Hickey建议他正确地组合了reduce和every?短路，或者我错过了一些已经存在的明显方法？

编辑：有两类人发布了避免在懒惰序列上进行分块的解决方案，但是如何在执行apply时避免分块，这似乎在四个分组中消耗？

编辑＃2：正如Stuart Sierra所说，我独立发现，这实际上并不是分块。它只是正常应用，所以我会把它叫做关闭并给他答案。对于那些感兴趣的人，我在一个单独的答案中包含了一个小函数来做问题的减少部分。

Answer 1

正确的两次：解除懒惰序列的简单方法：

(defn unchunk [s]
  (when (seq s)
    (lazy-seq
      (cons (first s)
            (unchunk (next s))))))

第一个版本省略了(when ...，因此在输入序列结束后它返回了无限的nil seq。

第二个版本使用first代替seq，因此它在nil停止。

RE：你的另一个问题，“我在申请时如何避免分块，这似乎在四人组合中消耗”：

这是由=的定义引起的，当给定一系列参数时，强制第一个4：

(defn =
  ;; ... other arities ...
  ([x y & more]
   (if (= x y)
     (if (next more)
       (recur y (first more) (next more))
       (= y (first more)))
     false)))

Answer 2

在apply的定义中查看clojure.core，可以明白当apply与无限序列一起使用时，为什么它以四个为一组进行分块。 Reduce也不会短路......所以我还在编写自己的解决方案：

(defn reducep
  "Like reduce, but for use with a predicate. Short-circuits on first false."
  ([p coll]
     (if-let [s (seq coll)]
       (reducep p (first s) (next s))
       (p)))
  ([p val coll]
     (if-let [s (seq coll)]
       (if-let [v (p val (first s))]
         (recur p (first s) (next s))
         false)
       true)))

然后使用Stuart的unchunk（带有额外的and）

(defn unchunk [s]
  (lazy-seq
   (cons (first s)
         (and (next s)
              (unchunk (next s))))))

我明白了：

(reducep = (map #(do (print %) %) (unchunk (range)))) ;; Prints 01, returns false
(reducep = (map #(do (print %) %) (repeat 20 1))) ;; returns true
(reducep = (map #(do (print %) %) (unchunk [0 0 2 4 5]))) ;; Returns false
(reducep = (map #(do (print %) %) (unchunk [2 2 2 2 2]))) ;; returns true

如果这对你也有效，请修改它。

编辑：Stuart在编辑后修改后的unchunk版本可能比之前发布的版本更好。

Answer 3

我在4clojure问题达到时间限制时发现了这篇文章我发现了另一种避免32块的方法：

;; add another dummy sequence parameter to the map:
(apply = (map #(do (prn %2) %) (range) (range)))

较高的arity形式的地图似乎不使用分块序列（clojure 1.5）

你必须对第二个参数做一些事情，所以存在明确可能会更好：

(apply = (map (fn [i _] (prn i) i) (range) (range)))

这不像其他解决方案那样整洁，但可能对快速和肮脏有好处使用，就像测试一样“因为分块这会很慢吗？”。

关于apply，您可以使用partition从序列中获取对，并且= =：

(every? #(apply = %) (partition 2 1
    (map (fn [i _] (prn i) i) (range) (range))))

虽然reducep看起来也很有用。

PS。我不想给人的印象是分块序列较慢，但事实并非如此。我的问题是4clojure测试用例在我的seq生成函数上调用“first” 一系列的价值观，所以分块意味着我做了32倍的工作。（PPS。我的代码仍然太慢）

如何避免Clojure对于我想要短路的懒惰seqs的分块行为？

3 个答案: