En Clojure, ¿los seces perezosos siempre se fragmentan?

Question

Tenía la impresión de que los seces perezosos siempre se fragmentaban.

=> (take 1 (map #(do (print \.) %) (range))) 
(................................0) 

Como era de esperar 32 puntos se imprimen porque el SEC perezoso devuelto por range está fragmentada en 32 trozos de elementos. Sin embargo, cuando en lugar de range Trato esto con mi propia función get-rss-feeds, la SEC perezoso ya no está fragmentada:

=> (take 1 (map #(do (print \.) %) (get-rss-feeds r))) 
(."http://wholehealthsource.blogspot.com/feeds/posts/default") 

Sólo un punto se imprime, así que supongo que los perezosos-ss devuelto por get-rss-feeds no está fragmentada. En efecto:

=> (chunked-seq? (seq (range))) 
true 

=> (chunked-seq? (seq (get-rss-feeds r))) 
false 

Aquí está la fuente de get-rss-feeds:

(defn get-rss-feeds 
    "returns a lazy seq of urls of all feeds; takes an html-resource from the enlive library" 
    [hr] 
    (map #(:href (:attrs %)) 
     (filter #(rss-feed? (:type (:attrs %))) (html/select hr [:link]))) 

lo que parece que chunkiness depende de cómo se produce la SEC perezoso. Eché un vistazo al origen de la función range y hay indicios de que se está implementando de una manera "gruesa". Así que estoy un poco confundido sobre cómo funciona esto. ¿Alguien puede aclarar?

---

He aquí por qué necesito saberlo.

tengo que siguiente código: (get-rss-entry (get-rss-feeds h-res) url)

La llamada a get-rss-feeds devuelve una secuencia perezosa de URLs de los feeds que tengo que examinar.

La llamada a get-rss-entry busca una entrada en particular (cuyo: campo de enlace coincide con el segundo argumento de get-rss-entry). Examina la secuencia diferida devuelta por get-rss-feeds. La evaluación de cada elemento requiere una solicitud http en la red para obtener un nuevo feed rss. Para minimizar el número de solicitudes http, es importante examinar la secuencia una a una y detenerla tan pronto como haya una coincidencia.

Aquí está el código:

(defn get-rss-entry 
    [feeds url] 
    (ffirst (drop-while empty? (map #(entry-with-url % url) feeds)))) 

entry-with-url devuelve una secuencia lenta de partidos o una secuencia vacía si no hay ninguna coincidencia.

Probé esto y parece funcionar correctamente (evaluando una URL de feed a la vez). Pero estoy preocupado de que en algún lugar, de alguna manera comience a comportarse de una manera "fornida" y comenzará a evaluar 32 avances a la vez. Sé que hay una manera de avoid chunky behavior as discussed here, pero parece que ni siquiera es necesario en este caso.

¿Estoy usando lazy seq non-idiomatically? ¿El bucle/repetición sería una mejor opción?

Answer 1

Dependiendo de la vaguedad de Chunking parece imprudente como mencionas arriba. Explicitamente, "desunir" en los casos donde realmente se necesita que no se fragmente, también es sabio porque si en algún otro momento su código cambia de una manera que lo rompe, las cosas no se romperán. En otra nota, si necesita que las acciones sean secuenciales, los agentes son una gran herramienta puede enviar las funciones de descarga a un agente y luego se ejecutarán una a la vez independientemente de cómo evalúe la función. En algún momento es posible que desee pmap su secuencia y, a continuación, incluso un-chunking no funcionará aunque el uso de un átomo seguirá funcionando correctamente.

Answer 2

Lazy seqs are no siempre fragmentada - depende de cómo se producen.

Por ejemplo, la SEC perezoso producido por esta función no está fragmentada:

(defn integers-from [n] 
    (lazy-seq (cons n (do (print \.) (integers-from (inc n)))))) 

(take 3 (integers-from 3)) 
=> (..3 .4 5) 

Pero muchas funciones incorporadas en otra clojure sí producen SEQs fragmentados por razones de rendimiento (por ejemplo range)

Answer 3

Usted está derecho a estar preocupado Su get-rss-entry de hecho llamará al entry-with-url más de lo estrictamente necesario si el parámetro feeds es una colección que devuelve seqs fragmentados. Por ejemplo, si feeds es un vector, map operará en trozos completos a la vez.

Este problema se aborda directamente en Fogus' alegría de Clojure, con la función seq1 define en el capítulo 12:

(defn seq1 [s] 
    (lazy-seq 
    (when-let [[x] (seq s)] 
     (cons x (seq1 (rest s)))))) 

usted podría utilizar este derecho donde se sabe que quiere sea posible el más pereza, a la derecha antes de llamar a entry-with-url:

 
(defn get-rss-entry 
    [feeds url] 
    (ffirst (drop-while empty? (map #(entry-with-url % url) (seq1 feeds)))))