如何在 Clojure 中将序列的分区（分解 w.r.t. 连接）定义为惰性序列的惰性序列

Question

我是 Clojure 的新手，我想定义一个函数 pt，将一个数字 n 和一个序列 s 作为参数，并在 n 部分中返回 s 的所有分区，即它的分解关于n-concatenation。例如(pt 3 [0 1 2]) 应该产生：

(([] [] [0 1 2]) ([] [0] [1 2]) ([] [0 1] [2]) ([] [0 1 2] []) ([0] [] [1 2]) ([0] [1] [2]) ([0] [1 2] []) ([0 1] [] [2]) ([0 1] [2] []) ([0 1 2] [] []))

顺序不重要。 具体来说，我希望结果是惰性向量序列的惰性序列。

我对这种功能的第一次尝试如下：

(defn pt [n s]
  (lazy-seq
    (if (zero? n)
      (when (empty? s) [nil])
      ((fn split [a b]
         (concat
           (map (partial cons a) (pt (dec n) b))
           (when-let [[bf & br] (seq b)] (split (conj a bf) br))))
       [] s))))

之后，我编写了一个不太简洁的版本，通过避免对 1 部分分区进行无用比较来降低时间复杂度，如下所示：

(defn pt [n s]
  (lazy-seq
    (if (zero? n)
      (when (empty? s) [nil])
      ((fn pt>0 [n s]
         (lazy-seq
           (if (= 1 n)
             [(cons (vec s) nil)]
             ((fn split [a b]
                (concat
                  (map (partial cons a) (pt>0 (dec n) b))
                  (when-let [[bf & br] (seq b)] (split (conj a bf) br))))
              [] s))))
       n s))))

这些解决方案的问题在于，尽管它们有效，但它们会产生一系列（非惰性）缺点的惰性序列，我怀疑必须采取完全不同的方法来实现“内在惰性”。因此，欢迎任何更正、建议、解释！

编辑：在阅读 l0st3d 的回答后，我想我应该明确指出，我不希望分区只是成为 LazySeq，而是“真正懒惰”，即计算一部分并且仅在请求时保存在内存中。 例如，下面给出的两个函数都会生成 LazySeq，但只有第一个函数会生成“非常惰性”的序列。

(defn f [n]
  (if (neg? n)
    (lazy-seq nil)
    (lazy-seq (cons n (f (dec n))))))

(defn f [n]
  (if (neg? n)
    (lazy-seq nil)
    (#(lazy-seq (cons n %)) (f (dec n)))))

所以映射(partial concat [a]) 或#(lazy-seq (cons a %)) 而不是(partial cons a) 并不能解决问题。

Answer 1

split inline fn 中的 cons 调用是唯一引入渴望的地方。你可以用懒惰地构造一个列表的东西来代替它，比如concat：

(defn pt [n s]
  (lazy-seq
   (if (zero? n)
     (when (empty? s) [nil])
     ((fn split [a b]
        (concat
         (map (partial concat [a]) (pt (dec n) b))
         (when-let [[bf & br] (seq b)] (split (conj a bf) br))))
      [] s))))

(every? #(= clojure.lang.LazySeq (class %)) (pt 3 [0 1 2 3])) ;; => true

但是，阅读代码我觉得它相当 unClojurey，我认为这与递归的使用有关。通常你会使用reductions、partition-by、split-at 之类的东西来做这种事情。我觉得还应该有一种方法可以使它成为一个转换器并将惰性从处理中分离出来（所以你可以使用sequence 说你想要它惰性），但我没有时间解决这个问题现在。我会尽快尝试并提供更完整的答案。