Clojure 执行一个延迟的函数序列

我想知道如何强制计算一个懒惰的函数序列

例如，如果我有一个返回整数1的函数：

test.core=> (fn [] 1)
#<core$eval2480$fn__2481 test.core$eval2480$fn__2481@4163c61>
test.core=> ((fn [] 1))
1

test.core=>（fn[]1）
#
test.core=>（（fn[]1））
1.

我构造了这些函数的惰性序列：

test.core=> (repeat 5 (fn [] 1))
(#<core$eval2488$fn__2489 test.core$eval2488$fn__2489@76fd6301> ...)

test.core=> (class (repeat 5 '(fn [] 1)))
clojure.lang.LazySeq

test.core=>（重复5（fn[]1））
(# ...)
test.core=>（类（重复5’（fn[]1）））
clojure.lang.LazySeq

如何实际执行序列中的函数

test.core=> (take 1 (repeat 5 (fn [] 1)))
(#<core$eval2492$fn__2493 test.core$eval2492$fn__2493@46e1e0c8>)

test.core=> (take 1 (repeat 5 '(fn [] 1)))
((fn [] 1))

test.core=> ((take 1 (repeat 5 '(fn [] 1))))

ClassCastException clojure.lang.LazySeq cannot be cast to clojure.lang.IFn

test.core=>（取1（重复5（fn[]1）））
(#)
test.core=>（取1（重复5’（fn[]1）））
（（fn[]1））
test.core=>（（取1（重复5’（fn[]1）））
ClassCastException clojure.lang.LazySeq不能强制转换为clojure.lang.IFn

我已经通读了，这表明多尔…但我不知道结果会怎样？我期待着[1]或类似的东西

test.core=> (doall (repeat 5 (fn [] 1)))
(#<core$eval2500$fn__2501 test.core$eval2500$fn__2501@14e3c50c>...)

test.core=> (realized? (doall (repeat 5 (fn [] 1))))
true

test.core=>（doall（重复5（fn[]1）））
(#...)
test.core=>（已实现？（doall（重复5（fn[]1）））
真的

您的问题是返回一系列未计算的函数。您可以按如下方式对其进行评估：

=> (map #(%) (repeat 5 (fn [] 1)))
(1 1 1 1 1)

---

map

和

repeat

都是惰性的，但是REPL或任何其他使用者都会强制对惰性序列进行至少所需的评估

您的问题是返回一系列未计算的函数。您可以按如下方式对其进行评估：

=> (map #(%) (repeat 5 (fn [] 1)))
(1 1 1 1 1)

---

map

和

repeat

都是惰性的，但是REPL或任何其他使用者都会强制对惰性序列进行至少所需的评估

您的问题是返回一系列未计算的函数。您可以按如下方式对其进行评估：

=> (map #(%) (repeat 5 (fn [] 1)))
(1 1 1 1 1)

---

map

和

repeat

都是惰性的，但是REPL或任何其他使用者都会强制对惰性序列进行至少所需的评估

您的问题是返回一系列未计算的函数。您可以按如下方式对其进行评估：

=> (map #(%) (repeat 5 (fn [] 1)))
(1 1 1 1 1)

---

map

和

repeat

都是惰性的，但是REPL或任何其他使用者都会强制对惰性序列进行至少所需的评估

值得注意的是，序列分块将导致仅对生成分块序列的函数（而

repeat

没有）以32的分块进行计算。分块有时很重要，但它可以安全地被忽略，直到OP找到如何调用函数列表的方法之后很久。值得注意的是，序列分块将导致仅对生成分块序列的函数（而

repeat

没有）以32个分块进行计算。分块有时很重要，但它可以安全地被忽略，直到OP找到如何调用函数列表的方法之后很久。值得注意的是，序列分块将导致仅对生成分块序列的函数（而

repeat

没有）以32个分块进行计算。分块有时很重要，但它可以安全地被忽略，直到OP找到如何调用函数列表的方法之后很久。值得注意的是，序列分块将导致仅对生成分块序列的函数（而

repeat

没有）以32个分块进行计算。分块有时很重要，但它可以安全地被忽略，直到OP知道如何调用函数列表之后很久。