(take 3 (iterate #(get get %) get))

(#object [clojure.core$get 0x3f888abb "clojure.core$get@3f888abb"] nil nil)

(dorun (take 3 (map println (iterate inc 0))))

nil

"0\n1\n2\n"

(map vector (iterate inc 0) [1 2 3])

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

(->> [[[[[[[1]]]]]]]
     (iterate first)
     (take-while sequential?)
     last
     first)

1

(take 5 (iterate #(str % "**") "*"))

("*" "***" "*****" "*******" "*********")

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

256

(defn even-numbers [] (iterate #(+ 2 %) 0))

#'user/even-numbers

(nth (iterate shuffle (range 100 0 -1)) 1000)

[93 86 59 17 50 11 67 54 64 25 80 14 98 53 51 21 61 8 60 39 55 38 32 58 85 27 26
 20 37 96 94 91 42 33 10 35 31 81 76 1 44 82 92 99 29 87 83 65 100 56 63 30 90
 41 12 68 89 43 69 6 18 13 57 49 88 97 28 2 5 15 78 24 23 45 7 72 34 3 70 47 71
 84 9 74 46 36 19 95 52 40 62 75 22 16 4 66 79 77 48 73]

(map prn [:a :b :c] (iterate inc 0))

(nil nil nil)

":a 0\n:b 1\n:c 2\n"

(do (first (map println (iterate inc 0))) nil)

nil

"0\n"

(defn foo [x] (iterate (partial + 3) x))

#'user/foo

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

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

(nth (iterate #(filter identity %) [1]) 10)

(1)

(nth (iterate #(filter identity %) [1]) 1000)

(1)

((juxt class (comp class rest)) (iterate inc 1))

[clojure.lang.Iterate clojure.lang.Iterate]

(take 1e4 (iterate #(* 0.5 %) 100))

(100 50.0 25.0 12.5 6.25 3.125 1.5625 0.78125 0.390625 0.1953125 0.09765625 0.048828125 0.0244140625 0.01220703125 0.006103515625 0.0030517578125 0.00152587890625 7.62939453125E-4 3.814697265625E-4 1.9073486328125E-4 9.5367431640625E-5 4.76837158203125E-5 2.384185791015625E-5 1.1920928955078125E-5 5.9604644775390625E-6 2.9802322387695312E-6 1.4901161193847656E-6 7.450580596923828E-7 3.725290298461...

(defn tails [xs] (take-while identity (iterate next xs)))

#'user/tails

(take 5 (iterate #(* % %) 2))

(2 4 16 256 65536)

(let [f #(* % %)] (map #(take %1 (iterate f %2)) (iterate inc 1) (range 10 14)))

((10) (11 121) (12 144 20736) (13 169 28561 815730721))

(take 10 (iterate #(* 2 %) 1))

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

(defn my-seq [s] (map first (iterate next s)))

#'user/my-seq

(take 5 (iterate #(+ %1 10) 0))

(0 10 20 30 40)

(map list [1 2 3] (iterate inc 10))

((1 10) (2 11) (3 12))

(take 4 (iterate #(* 2 %) 2))

(2 4 8 16)

(take 4 (iterate #(+ 0.25 %) 0))

(0 0.25 0.5 0.75)

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

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

(zipmap [:a :b :c :d] (iterate inc 0))

{:a 0, :b 1, :c 2, :d 3}

(nth (iterate #(+ 7 %) 0) 4242)

29694

(take-while #(<= % 0) (iterate inc -10))

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

(take 10 (iterate #(/ % 2) 20))

(20 10 5 5/2 5/4 5/8 5/16 5/32 5/64 5/128)

(apply sorted-map (interleave (range 10) (iterate inc 100)))

{0 100, 1 101, 2 102, 3 103, 4 104, 5 105, 6 106, 7 107, 8 108, 9 109}

((fn [aseq] (nth aseq 1000000)) (iterate inc 1))

1000001

(take 10 (iterate #(* 2 %) 4))

(4 8 16 32 64 128 256 512 1024 2048)

(take 4 (iterate (partial mapv inc) [0 0]))

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

(do (rest (map println (iterate inc 0))) nil)

nil

"0\n"

(nth (iterate rest [1 2 3 4]) 3)

(4)

(map vector [:foo :bar :baz] (iterate inc 0))

([:foo 0] [:bar 1] [:baz 2])

(take 5 (iterate #(%) (apply partial (repeat partial))))

(#object[clojure.core$partial$fn__5914 0xa3ab775 "clojure.core$partial$fn__5914@a3ab775"] #object[clojure.core$partial$fn__5914 0x4fd5842 "clojure.core$partial$fn__5914@4fd5842"] #object[clojure.core$partial$fn__5914 0xc2dc05 "clojure.core$partial$fn__5914@c2dc05"] #object[clojure.core$partial$fn__5914 0x45c05279 "clojure.core$partial$fn__5914@45c05279"] #object[clojure.core$partial$fn__5914 0x1a1...

(take-while seq (iterate rest [1 2 3 4 5]))

([1 2 3 4 5] (2 3 4 5) (3 4 5) (4 5) (5))

(apply (partial #(second %&) :skip) (iterate inc 0))

0

(take 3 (iterate #(conj % "hi") (list "hi")))

(("hi") ("hi" "hi") ("hi" "hi" "hi"))

(let [x (drop 3 (iterate inc 1))] (println "foo"))

nil

"foo\n"

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

([1 2 3 4 5] [1 2 3 4] [1 2 3] [1 2] [1])

(meta (drop 10 (with-meta (iterate inc 1) {:type ::foo})))

nil

(take 4 (iterate (fn [x] (* x x)) 2))

(2 4 16 256)

(nth (iterate #(doall (remove identity %)) [1]) 1000)

()

(->> (iterate inc 1)
     (map + (range))
     (take 5))

(1 3 5 7 9)

((fn fatten [x] (nth (iterate list x) 10)) 5)

((((((((((5))))))))))

((zipmap [:a :b :c :d] (iterate inc 0)) :b)

1

(take 3 (drop 1 (iterate #(conj % :a) [])))

([:a] [:a :a] [:a :a :a])