Clojure 我可以一步一步地处理一个未实现的惰性seq吗

我有一个懒惰的seq，其中每个项目都需要一些时间来计算：

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

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

编辑1：

JohnJ的答案展示了如何创建一个将逐步评估的惰性seq。我想知道如何一步一步地评估任何懒惰的seq

我很困惑，因为在上面定义的gen lazy seq上运行

（chunked seq？（gen lazy seq 10））

，或者在JohnJ的答案中定义的，都返回false。因此，问题不可能是一个创建了分块序列，而另一个没有

作为回答，显示了一个函数seq1，它将一个分块的惰性seq转换为一个非分块的seq。尝试该函数仍然会导致输出延迟的问题。我认为延迟可能和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：

不仅仅是生成的序列有这个问题。无论seq1如何包装，都无法逐步处理使用map生成的此序列：

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

但这一序列也是用map works创建的：

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

---

Clojure的惰性序列通常是分块的。如果使用大的

size

s，您可以在示例中看到分块的作用（在这种情况下，这将有助于减少线程睡眠时间）。另见

尽管的

似乎是分块的，但以下内容并非如此，并且可以根据需要工作：

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

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

“我有通过网络发送的消息，我想在收到所有消息之前开始处理它们。”分块或不分块，如果您懒散地处理它们，事实上应该是这样。
我也尝试了
seq1
，但未能使其与Clojure 1.5或1.2.1配合使用。这可能是因为您在实现

for宏时遇到了一些特殊情况，它不是透明的，您不能简单地通过将其包装在自己的惰性序列中来关闭它。感谢您的测试。这一问题是由……引起的，这似乎是合理的。我试着用map创建一个懒惰的seq，结果正如预期的那样。通过测试，似乎我对map生成的序列也有同样的问题。