Предполагается ли ленивая последовательность?

Question

Могу ли я с уверенностью предположить, что при выполнении

(gen-sym-map (gen-acct-num-sym @sym-count (gen-acct-nums 10)) 100.00)

у меня есть lazy-sequence, или gen-sym-map должен возвращать полученную карту в вызове функции lazy-seq?

(defn gen-acct-nums [range-end-idx]
    (vec (range 10000 (+ 10000  range-end-idx 1))))

(defn random-acct-num [acct-nums]
    (nth acct-nums (.nextInt random (count acct-nums))))

(defn gen-acct-num-sym [num-syms acct-nums]
    (loop [snum num-syms acct-num-lis []]
        (if (= snum 0)
                acct-num-lis
                (recur (dec snum) (conj acct-num-lis (random-acct-num acct-nums))))))

(defn gen-sym-map-day [acct-nums starting-bal]
    (reduce
        (fn [sym-map one-acct-num]
            (let [trans (random-trans )
                  amt   (random-amount )]
                (conj sym-map { one-acct-num (vector trans amt starting-bal) } )))
        {}
        acct-nums))

(defn gen-sym-map [acct-nums starting-bal]
    (loop [day-count-left @sym-day-count current-day 1 sym-map-local  {}]
        (if (= day-count-left 0)
            sym-map-local
            (recur (dec day-count-left) (inc current-day)
                    (conj sym-map-local {(gen-map-key current-day)
                                    (gen-sym-map-day acct-nums starting-bal)} )))))

Answer 1

Вы не получаете ленивую последовательность в этой ситуации.

Это по разным причинам:

• Вы строите карту.Карты не ленивые, только последовательности.
• Большинство ваших функций написаны с использованием цикла / повторения, которые по своей сути являются императивными и не ленивыми.
• Стоит также отметить, что vec , уменьшение и count также не ленивы, в том смысле, что они должны потреблять весь вводпоследовательность.Поэтому всякий раз, когда вы используете эти функции, вся ваша последовательность будет реализована, и вы потеряете преимущество лени.

Если вы хотите использовать ленивую последовательность в Clojure, обычно проще всего написать код в терминахфункций высшего порядка, которые производят последовательности, такие как map и filter .Большинство функций, производящих последовательности, по умолчанию создают ленивые последовательности.

Конечно, вы можете заключить в lazy-seq , если хотите создать ленивую последовательность, но для этого требуется следующее:

• Ваш вывод должен быть в форме последовательности
• У вас есть способ лениво построить свой вывод без осознания полного результата (в противном случае использование lazy-seq довольно бессмысленно)...)

Классическим использованием lazy-seq было бы использование некоторых функций и рекурсии более высокого порядка для определения (возможно бесконечной) ленивой последовательности, например, следующим образом:

(def fibs (concat [1 2] (lazy-seq (map + fibs (next fibs)))))