(nth (map pr (iterate inc 1)) 2)

nil

"123"

(-> (iterate list ())
    (nth 2000)
    flatten
    count)

0

(binding [*print-length* 10] (prn (iterate inc 1)))

nil

"(1 2 3 4 5 6 7 8 9 10 ...)\n"

(flatten (last (take 5000 (iterate list nil))))

(nil)

(def n (map count (iterate pr-str "\\")))

#'user/n

(first (reverse (take 100 (iterate list 1))))

(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((1)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

(take 10 (iterate #(+ %) 0.0))

(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)

(take 100 (iterate (fn [x] :foo) :foo))

(:foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo :foo...

(zipmap [:foo :bar :baz] (iterate inc 0))

{:bar 1, :baz 2, :foo 0}

(nth (iterate #(hash-map % %) {}) 4)

{{{{{} {}} {{} {}}} {{{} {}} {{} {}}}} {{{{} {}} {{} {}}} {{{} {}} {{} {}}}}}

(take 2 (map print (iterate inc 0)))

(nil nil)

"01"

(drop 9 (take 10 (iterate inc 0)))

(9)

(reduce - (take 3 (iterate dec 99)))

-96

(partition 4 (take 15 (iterate inc 1)))

((1 2 3 4) (5 6 7 8) (9 10 11 12))

(take-while (partial > 5) (iterate inc 2))

(2 3 4)

(zipmap [1 2 3] (iterate inc 10))

{1 10, 2 11, 3 12}

(take 2 (remove even? (iterate inc 0)))

(1 3)

(take (- 10 1) (iterate inc 1))

(1 2 3 4 5 6 7 8 9)

(take 10 (iterate (partial + 0.1) 0))

(0
 0.1
 0.2
 0.30000000000000004
 0.4
 0.5
 0.6
 0.7
 0.7999999999999999
 0.8999999999999999)

(take 2 (partition 2 (iterate inc 0)))

((0 1) (2 3))

(take 10 (reductions + (iterate inc 1)))

(1 3 6 10 15 21 28 36 45 55)

(take 5 (reductions + (iterate inc 0)))

(0 1 3 6 10)

(nth (iterate (partial * 2) 1) 8)

256

(= [1 2 3] (iterate inc 1))

false

(partition 3 (take 15 (iterate inc 1)))

((1 2 3) (4 5 6) (7 8 9) (10 11 12) (13 14 15))

(take 2 (iterate rest [1 2 3]))

([1 2 3] (2 3))

(take 10 (cons 0 (iterate inc 1)))

(0 1 2 3 4 5 6 7 8 9)

(reduce * (take 5 (iterate inc 1)))

120

((comp (partial take 10) iterate) inc 0)

(0 1 2 3 4 5 6 7 8 9)

(take 1 (map println (iterate inc 0)))

(nil)

"0\n"

(take (- 10 -20) (iterate inc -20))

(-20
 -19
 -18
 -17
 -16
 -15
 -14
 -13
 -12
 -11
 -10
 -9
 -8
 -7
 -6
 -5
 -4
 -3
 -2
 -1
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9)

(apply list (take 5 (iterate inc 0)))

(0 1 2 3 4)

(take 2 (iterate (fn [x] x) :foo))

(:foo :foo)

(take 10 (iterate (partial * 2) 3))

(3 6 12 24 48 96 192 384 768 1536)

(second (doall [(iterate inc 0) [1 2]]))

[1 2]

(take 8 (iterate (partial + 9) 0))

(0 9 18 27 36 45 54 63)

(take 5 (drop 5 (iterate inc 1)))

(6 7 8 9 10)

(take-while seq (iterate pop [1 2 3]))

([1 2 3] [1 2] [1])

(apply str (take 10 (iterate inc 0)))

"0123456789"

(type (seq (take 20 (iterate inc 0))))

clojure.lang.Cons

(= (iterate inc 1) [1 2 3])

false

(take 2 (iterate #(prn %1) "no"))

("no" nil)

"\"no\"\n"

(take 10 (iterate (partial + 2) 0))

(0 2 4 6 8 10 12 14 16 18)

(take 5 (iterate dec (/ 10 3)))

(10/3 7/3 4/3 1/3 -2/3)

(take-while (partial < 1000) (iterate inc 1))

()

(def b (iterate (fn [_] (rand)) 1))

#'user/b

(first (reverse (take 20 (iterate list '()))))

(((((((((((((((((((())))))))))))))))))))

(apply + (take 10 (iterate inc 0)))

45

(take-while seq (iterate next [1 2 3]))

([1 2 3] (2 3) (3))

(take 10 (iterate (partial * 2) 1))

(1 2 4 8 16 32 64 128 256 512)