43

I'm having trouble understanding how one creates a lazy sequence in Clojure.

The documentation for the macro isn't at all clear to me:

Usage: (lazy-seq & body) Takes a body of expressions that returns an ISeq or nil, and yields a Seqable object that will invoke the body only the first time seq is called, and will cache the result and return it on all subsequent seq calls.

All the examples that I've seen, seem to do something like the following:

; return everything in the sequence starting at idx n
(defn myseq-after-n [n]
  (...)
)

(def my-lazy-seq
  (lazy-seq (conj [init-value] (myseq-after-n 2)))
)

So, the first thing I don't get is, since lazy-seq is outside the call to conj, how does it prevent conj from generating an infinite sequence at evaluation?

My second question is, do lazy sequence definitions always take this general form?

lightlazer
  • 133
  • 1
  • 5
Kricket
  • 4,049
  • 8
  • 33
  • 46

1 Answers1

57

A lazy-seq call just executes the body once the first time it is accessed, then caches and returns the same result whenever it is called again in the future.

If you want to use this to build long (or even infinite) sequences, then you need to recursively nest other lazy-seq calls in the returned sequence. Here's about the simplest case I can think of:

(defn ints-from [n]
  (cons n (lazy-seq (ints-from (inc n)))))

(take 10 (ints-from 7))
=> (7 8 9 10 11 12 13 14 15 16)

Any (ints-from n) call produces a sequence starting with n, followed by a lazy sequence of (ints-from (inc n)). It's an infinite list, but that's not a problem because the lazy-seq ensures that (int-from (inc n)) only gets called when it is needed. You could try exactly the same code without the lazy-seq and you'd get a StackOverflowError very quickly.

lazy-seq is just one of many possible ways to create lazy sequences, and it often isn't the most convenient. The following are some other interesting/useful ways to create lazy sequences:

; range is an easy way to get an infinite lazy sequence of integers, starting with zero     
(take 10 (range))
=> (0 1 2 3 4 5 6 7 8 9)

; map produces lazy sequences, so the following is lazy 
(take 10 (map #(* % %) (range)))
=> (0 1 4 9 16 25 36 49 64 81)

; iterate is a good way of making infinite sequenes of the form x, f(x), f(f(x))..... 
(take 10 (iterate (partial * 2) 1))
=> (1 2 4 8 16 32 64 128 256 512)
mikera
  • 105,238
  • 25
  • 256
  • 415
  • 1
    shouldn't the lazy-seq be outside the cons: (defn from [n] (lazy-seq (cons n (from (+ 1 n))))) ? – andrew cooke Mar 19 '12 at 21:21
  • 8
    @andrew: it doesn't really matter which order you put them. putting cons first is very slightly more efficient since it means the first object just is a cons rather than a lazy-seq that contains a cons. So you use one less object..... not a big deal though! – mikera Mar 20 '12 at 01:28
  • 6
    Well, it might matter quite a bit, depending on circumstances. With this code you are eagerly evaluating the first member. In your case no problem, but that's not always so. – Marko Topolnik Apr 20 '12 at 10:22
  • Hi, just trying to get to know how lazy-seqs work and are used in clojure, is this answer still relevant as before? can you confirm this documents has the terms for next and rest backwards? http://clojure.org/lazy – user1644340 Mar 19 '14 at 04:00
  • As it turns out, if you want to use the function realised? to check if the lazy sequence was realised, you need to put cons inside lazy-seq block, because LazySeq object implements IPending interface, clojure.lang.Cons does not, it wouldn't make sense anyway. So realised? function expects to LazySeq argument. – Simon Polak Jul 24 '16 at 15:43