Gotcha: holding onto the head

When you make a lazy sequence, before it is realized, it takes up very little space in memory. But as you realize elements of it, they are saved. If the list is very long, that can take up a lot of memory. Luckily, it will be garbage collected as soon as it goes out of scope. But sometimes, it can't go out of scope because you're still referencing the list. This is often because you've got the list bound to a local variable. The problem is common. It's called holding onto the head. The solution is to avoid referencing the beginning of the list any more than you need to. The garbage collector can take care of the rest.

;; this may run out of memory
(defn print-multiples-of-1000000 []
  (let [integers (range)
        millions (filter #(zero? (mod % 1000000)) integers)
        million-and-ones (filter #(zero? (mod% 1000001)) integers)]
    (doseq [i (take 3 millions)]
      (println i))
    (doseq [i (take 3 million-and-ones)]
      (println i))))

;; this won't
(defn print-multiples-of-1000000 []
  (let [;;integers (range)
        millions (filter #(zero? (mod % 1000000)) (range))
        million-and-ones (filter #(zero? (mod% 1000001)) (range))]
    (doseq [i (take 3 millions)]
      (println i))
    (doseq [i (take 3 million-and-ones)]
      (println i))))