Clojure:在循环另一个 collection 的同时循环一个 collection?
Clojure: Cycle through a collection while looping through another collection?
我有两个 collections x
和 y
,它们都有不同数量的项目。我想循环 x
并用 side-effect 做一些事情,同时循环 y
。我不想在循环 x
时重复 y
。 doseq
和 for
都重复 y
:
(for [x (range 5)
y ["A" "B"]]
[x y])
这会产生 ([0 "A"] [0 "B"] [1 "A"] [1 "B"] [2 "A"] [2 "B"] [3 "A"] [3 "B"] [4 "A"] [4 "B"])
。
我想要的是会产生的东西:([0 "A"] [1 "B"] [2 "A"] [3 "B"] [4 "A"])
.
背景,我有来自文件的行和 core.async
个频道(比如 5 个),我想将每一行放到我的 collection 中的下一个频道,例如:
(defn load-data
[file chans]
(with-open [rdr (io/reader file)]
(go
(doseq [l (line-seq rdr)
ch chans]
(>! ch l)))))
如果您将多个序列传递给 map
,它会以锁步方式遍历每个序列,并使用每个序列中当前位置的值调用映射函数。当其中一个序列用完时停止。
user> (map vector (range 5) (cycle ["A" "B"]))
([0 "A"] [1 "B"] [2 "A"] [3 "B"] [4 "A"])
在这种情况下,来自 (cycle ["A" "B"])
的序列将永远生成 A 和 B,尽管当来自 (range 5)
的序列结束时,map 将停止使用它们。然后每一步使用这两个参数调用向量函数并将结果添加到输出序列。
对于第二个示例,使用 go-loop 是散开输入序列的相当标准的方法:
user> (require '[clojure.core.async :refer [go go-loop <! <!! >!! >! chan close!]])
nil
user> (defn fanout [channels file-lines]
(go-loop [[ch & chans] (cycle channels)
[line & lines] file-lines]
(if line
(do
(>! ch line)
(recur chans lines))
(doseq [c channels]
(close! c)))))
#'user/fanout
user> (def lines ["first" "second" "third" "fourth" "fifth"])
#'user/lines
user> (def test-chans [(chan) (chan) (chan)])
#'user/test-chans
user> (fanout test-chans lines)
#<ManyToManyChannel clojure.core.async.impl.channels.ManyToManyChannel@3b363fc5>
user> (map <!! test-chans)
("first" "second" "third")
user> (map <!! test-chans)
("fourth" "fifth" nil)
我有两个 collections x
和 y
,它们都有不同数量的项目。我想循环 x
并用 side-effect 做一些事情,同时循环 y
。我不想在循环 x
时重复 y
。 doseq
和 for
都重复 y
:
(for [x (range 5)
y ["A" "B"]]
[x y])
这会产生 ([0 "A"] [0 "B"] [1 "A"] [1 "B"] [2 "A"] [2 "B"] [3 "A"] [3 "B"] [4 "A"] [4 "B"])
。
我想要的是会产生的东西:([0 "A"] [1 "B"] [2 "A"] [3 "B"] [4 "A"])
.
背景,我有来自文件的行和 core.async
个频道(比如 5 个),我想将每一行放到我的 collection 中的下一个频道,例如:
(defn load-data
[file chans]
(with-open [rdr (io/reader file)]
(go
(doseq [l (line-seq rdr)
ch chans]
(>! ch l)))))
如果您将多个序列传递给 map
,它会以锁步方式遍历每个序列,并使用每个序列中当前位置的值调用映射函数。当其中一个序列用完时停止。
user> (map vector (range 5) (cycle ["A" "B"]))
([0 "A"] [1 "B"] [2 "A"] [3 "B"] [4 "A"])
在这种情况下,来自 (cycle ["A" "B"])
的序列将永远生成 A 和 B,尽管当来自 (range 5)
的序列结束时,map 将停止使用它们。然后每一步使用这两个参数调用向量函数并将结果添加到输出序列。
对于第二个示例,使用 go-loop 是散开输入序列的相当标准的方法:
user> (require '[clojure.core.async :refer [go go-loop <! <!! >!! >! chan close!]])
nil
user> (defn fanout [channels file-lines]
(go-loop [[ch & chans] (cycle channels)
[line & lines] file-lines]
(if line
(do
(>! ch line)
(recur chans lines))
(doseq [c channels]
(close! c)))))
#'user/fanout
user> (def lines ["first" "second" "third" "fourth" "fifth"])
#'user/lines
user> (def test-chans [(chan) (chan) (chan)])
#'user/test-chans
user> (fanout test-chans lines)
#<ManyToManyChannel clojure.core.async.impl.channels.ManyToManyChannel@3b363fc5>
user> (map <!! test-chans)
("first" "second" "third")
user> (map <!! test-chans)
("fourth" "fifth" nil)