我可以一步一步地处理一个未实现的懒惰序列吗

Question

(defn gen-lazy-seq [size]
  (for [i (range size)]
    (do
      (Thread/sleep 1000)
      (rand-int 10))))

(doseq [item (gen-lazy-seq 10)]
  (println item))

(for [item (gen-lazy-seq 10)]
  (println item))

这两个表达式都将等待10秒，然后才打印出任何内容。我已经将doall和dorun作为解决方案，但它们要求lazy-seq生产函数包含println。我想分别定义一个lazy-seq生产函数和lazy-seq打印函数，并使它们逐项协同工作。

尝试这样做的动机：我有来自网络的消息，我希望在所有消息都收到之前就开始处理它们。同时，最好将与查询对应的所有消息保存在一个lazy-seq中。

编辑1：

(defn seq1 [s]
  (lazy-seq
    (when-let [[x] (seq s)]
      (cons x (seq1 (rest s))))))

(let [start-time (java.lang.System/currentTimeMillis)]
  (doseq [item (seq1 (gen-lazy-seq 10))]
    (let [elapsed-time (- (java.lang.System/currentTimeMillis) start-time)]
      (println "time: " elapsed-time "item: " item))))

; output:
time:  10002 item:  1
time:  10002 item:  8
time:  10003 item:  9
time:  10003 item:  1
time:  10003 item:  7
time:  10003 item:  2
time:  10004 item:  0
time:  10004 item:  3
time:  10004 item:  5
time:  10004 item:  0

; output:
time:  1002 item:  4
time:  2002 item:  1
time:  3002 item:  6
time:  4002 item:  8
time:  5002 item:  8
time:  6002 item:  4
time:  7002 item:  5
time:  8002 item:  6
time:  9003 item:  1
time:  10003 item:  4

不仅仅是用它生成的序列有这个问题。无论seq1换行如何，都不能逐步处理用map生成的这个序列：

(defn gen-lazy-seq [size]
  (map (fn [_] 
         (Thread/sleep 1000)
         (rand-int 10))
       (range 0 size)))

但是这个序列，也是用map创建的：

(defn gen-lazy-seq [size] 
  (map (fn [_] 
         (Thread/sleep 1000)
         (rand-int 10))
       (repeat size :ignored)))

Answer 1

Clojure的懒惰序列通常是分块的。如果采用较大的大小，您可以在示例中看到分块在工作（在这种情况下，这将有助于减少线程Hibernate时间）。另见这些相关的SO帖子。

虽然for似乎是分块的，但以下内容并不是按需要工作的：

(defn gen-lazy-seq [size]
  (take size (repeatedly #(do (Thread/sleep 1000)
                              (rand-int 10)))))

(doseq [item (gen-lazy-seq 10)]
  (println item)) 

“我有来自网络的消息，我想在所有消息都收到之前开始处理它们。”分块或不分块，如果你懒洋洋地处理它们，实际上应该是这样。