通过连接集合创建惰性序列

Question

通过连接集合创建惰性序列。

考虑以下函数：

(defn req []
  (Thread/sleep 1000)
  (repeat 4 (rand-int 10)))

添加睡眠是因为函数最终将是一个http请求，因此它应该模拟一个延迟。

示例输出：

(req)
;; (8 8 8 8)

(req)
;; (4 4 4 4)

我现在正在考虑一个函数，它通过串联后续req 结果创建一个惰性序列。

(take 10 (f req))
;; (3 3 3 3 2 2 2 2 9 9)

这是一种实现方式：

(defn f [g]
  (lazy-seq (concat (g) (f g))))

这是要走的路吗？我以某种方式猜测可能已经有一个可用的抽象。我试过lazy-cat，但这个宏似乎只适用于固定数量的给定序列。

---

事实证明这是一个有效的抽象：

(take 10 (apply concat (repeatedly req)))

但是，惰性序列的分块看起来会导致req 在这里被调用的频率超过了这里所需的频率，如果它是一个 http 请求，这是不可接受的。

Answer 1

由于apply needs to know 传递函数应用于的参数数量，正在发生“不需要”的惰性序列元素实现。

快速浏览一下 Clojure 核心库，似乎它没有提供连接一系列序列的功能，同时，以您想要的方式处理惰性（没有多余地实现传递的惰性序列的元素），因此，您需要自己实现它。

以下是可能的解决方案：

(defn apply-concat [xs]
  (lazy-seq
   (when-let [s (seq xs)]
     (concat (first s) (apply-concat (rest s))))))

然后：

user> (defn req []
        (println "--> making request")
        [1 2 3 4])
#'user/req
user> (dorun (take 4 (apply-concat (repeatedly req))))
--> making request
nil
user> (dorun (take 5 (apply-concat (repeatedly req))))
--> making request
--> making request
nil
user> (dorun (take 8 (apply-concat (repeatedly req))))
--> making request
--> making request
nil
user> (dorun (take 9 (apply-concat (repeatedly req))))
--> making request
--> making request
--> making request
nil

这种方法的唯一顾虑是爆栈的危险，因为apply-concat 可能是无限递归的。

更新：

准确地说apply实现了(arity of passed function + 1)传递的惰性序列的元素：

user> (dorun (take 1 (apply (fn [& xs] xs) (repeatedly req))))
--> making request
--> making request
nil
user> (dorun (take 1 (apply (fn [x & xs] xs) (repeatedly req))))
--> making request
--> making request
--> making request
nil
user> (dorun (take 1 (apply (fn [x y & xs] xs) (repeatedly req))))
--> making request
--> making request
--> making request
--> making request
nil

Answer 2

怎么样

(take 14 
  (mapcat identity (repeatedly req)))

解释：

(defn req [] 
  (print ".") 
  (repeat 4 (rand-int 10)))

(def x 
  (take 80 (mapcat identity (repeatedly req))))
; prints .... = 4x ; this is probably some repl eagerness

; to take 80 items, 20 realizatons (of 4 items) are requrend 
(def y 
  (doall
    (take 80 (mapcat identity (repeatedly req))))) 
 ; prints ..................... = 21x 

编辑：关于这 4 个早期认识：

我认为这是由于apply，我们被mapcat 使用。 给定多个参数，它最多可以实现 4 个参数 [^clojure.lang.IFn f a b c d & args]。