clojure - 我可以逐步处理未实现的惰性序列吗

Question

我有一个惰性序列，其中每个项目都需要一些时间来计算:

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

是否可以逐步评估这个序列并打印结果。当我尝试使用 for 或 doseq 处理它时，clojure 总是在打印任何内容之前实现整个惰性序列:

(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打印函数，让它们逐项协同工作。

尝试这样做的动机:我有通过网络传入的消息，我想在收到所有消息之前开始处理它们。同时，最好将与查询对应的所有消息保存在惰性序列中。

编辑 1:

JohnJ 的回答展示了如何创建一个将被逐步评估的惰性序列。我想知道如何逐步评估任何惰性序列。

我很困惑，因为在上面定义的 gen-lazy-seq 上运行 (chunked-seq? (gen-lazy-seq 10)) 或 JohnJ 的答案中定义的都返回 false。所以问题不可能是一个创建了分块序列而另一个没有。

在this回答，显示了一个函数 seq1 ，它将一个分块的惰性序列变成一个非分块的惰性序列。尝试该功能仍然会出现延迟输出的相同问题。我认为延迟可能与 repl 中的某种缓冲有关，所以我也尝试打印 seq 中每个项目实现的时间:

(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

用 JohnJ 的 gen-lazy-seq 版本做同样的事情会按预期工作

; 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

编辑 2:

不仅是用 for 生成的序列有这个问题。这个用map生成的sequence不管seq1 wrapping是不能一步步处理的:

(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 的惰性序列通常是分块的。如果您采用较大的 size(在这种情况下，这将有助于减少线程休眠时间)，您可以在您的示例中看到工作中的分块。另见 these related SO posts .

虽然 for 看起来是分块的，但下面的代码不是，并且可以按预期工作:

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

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

“我有通过网络传入的消息，我想在收到所有消息之前开始处理它们。”分块或不分块，如果您懒惰地处理它们，实际上应该是这种情况。