延迟使用http请求

我正在尝试丰富数据，我可以使用的界面是一个web表单。 由于远程端的数据质量很差，我会进行一系列不同的搜索，直到找到匹配项。有时我在第一次请求时就被击中了，有时即使我尝试了5次不同的搜索，也找不到任何东西

我想我可以利用Clojures的懒惰来缩短第一场比赛的搜索时间，但显然由于副作用，每次都会要求进行5次不同的搜索

下面是我的问题的一个非常简单的再现：

(ns lazy-web-lookup.core
  (:require [clj-http.client :as http]))

(defn found?
  "Determines if the search was successful"
  [result]
  (= (:found result) "yes"))

(first (filter #(found? %) (map #(hash-map :no %
                                           :found (:body (http/get "http://localhost/random"))) [1 2 3 4 5])))

http://localhost/random

随机返回字符串“是”或“否”

---

不管怎样，我是否可以调整上面的内容来做我想做的事情，还是我选错了树？

出于效率考虑，惰性序列一次评估32个元素。试试这个：

> (defn f [i] (= i 2))
#'sandbox10079/f
> (defn g [i] (println "THIS IS" i) i))
#'sandbox10079/g
> (defn h [x] (first (filter f (map g x))))
#'sandbox10079/h
> (h (range 40))
THIS IS 0
THIS IS 1
THIS IS 2
THIS IS 3
THIS IS 4
THIS IS 5
  ...
THIS IS 28
THIS IS 29
THIS IS 30
THIS IS 31
2
>  

---

如其他答案中所述，惰性序列在批处理模式下实现，其中批处理大小为32，对于您的特定问题，您可以使用普通的旧递归：

(loop [i [1 2 3 4 5]]
  (when (seq i)
    (let [body (-> (http/get "http://localhost/random")
                   :body)]
      (if (= body "yes")
        body
        (recur (rest i))))))

实际上，只有分块的序列才能成批实现（通常为1）32个元素。非分块序列一次实现一个。像

map

和

filter

这样的函数保留其seq参数的分块/未分块“模式”

因此，如果您确保向常规Clojure序列函数传递一个非分块的seq，那么您就可以在不牺牲任何惰性的情况下使用它们。这里有两种可能的方法，第二种可能更适用于您的情况：

制作你的seq而不考虑它是否会被分块；然后，如果它恰好被分块，则将其包装在“未分块的seq”中：

要在问题文本中的示例中使用此方法，您必须在向量

[1 2 3 4 5]

以某种方式生成初始seq（转换管道中最内层的seq），这种方式不会对输出进行分块。这可能涉及明确编写自己的制作人：

(defn my-seq-producer [& args]
  (lazy-seq
    (if ...
      (cons (foo) (my-seq-producer ...))))

这里需要注意的关键是，您正在将一个

cons

调用包装在一个条件内部

lazy seq

。如果条件中的测试不满足，则条件将产生

nil

，并且延迟序列在实现后将变为空；否则，

（foo）

将作为输出的第一个元素生成，然后是序列的“rest”部分，而不进行任何分块

特别是，如果您编写自己的通过HTTP获取的项目惰性序列的生产者，您将能够使用核心序列函数对其进行转换，同时保持完全惰性。

判断哪个seq是分块的，哪个不是分块的最简单方法是使用

chunked seq？

函数，尽管有两个注意事项：

您可能应该使用

chunked seq？

作为对您感兴趣的任何一个seq调用

seq

的结果，而不是原始seq本身。这是因为您的seq可能是一个用

LazySeq

对象包装的、产生thunk的分块seq。事实上，

范围

就是这种情况

(chunked-seq? (range 40))
;= false

(chunked-seq? (seq (range 40)))
;= true

seq可以部分分块；例如，您可以

cons

将某个内容放在分块seq的前面，从而生成一个没有分块的seq，但仍然有一个分块的“rest”。显式unchunking很好地解决了这个问题，因为它并没有真正检查底层seq是否被分块

---

---

1考虑在尾部小于32个元素的向量上的SEQ。

参见：谢谢解释。这个unCungk看起来相当棒：）个人而言，我喜欢MAP滤波器的结构比循环重复更好。您对比较这两种解决方案有何评论？对于转换数据序列，我通常会首先使用序列库函数，并且只有在感觉特别清晰或者可以衡量显著的性能优势时才使用循环/重现。Loop/recur过去对于提前完成某些类型的转换很有用，但现在

reduce

可以短路（请参见Clojure>=1.5中的

（doc reduced）

），这种情况就不那么常见了。seq transforms的声明性感觉是一个原因；此外，循环/重现是闭合的，而seq转换是开放的：您可以在管道的顶部堆叠更多内容，而无需对其进行修改。

(chunked-seq? (range 40))
;= false

(chunked-seq? (seq (range 40)))
;= true