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

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

(map #(take %1 (iterate inc %1)) (range 5))

(() (1) (2 3) (3 4 5) (4 5 6 7))

(let [evens (iterate #(+ 2 %) 0)
      odds (iterate #(+ 2 %) 1)]
  (take 20 (concat evens odds)))

(0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38)

(first (apply (fn [& r] r) (iterate inc 1)))

1

(first (iterate #(do (prn %) (inc %)) 0))

0

(def multiples-of-20 (iterate (fn [x] (+ x 20)) 20))

#'user/multiples-of-20

(take 10 (iterate rest [1 2 3 4 5]))

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

(apply (fn [& args] (first args)) (iterate inc 1))

1

(nth (iterate (juxt first second) '[first second]) 1000)

[first second]

(map vector (iterate inc 0) '(foo bar baz))

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

(nth (iterate pop [1 2 3 4 5]) 3)

[1 2]

(apply (fn [& x] (first x)) (iterate inc 0))

0

(first (remove {1 2, 3 4} (iterate inc 1)))

2

(take 3 (apply concat (repeatedly #(iterate inc 0))))

(0 1 2)

(for [i (iterate inc 0) :while (even? i)] i)

(0)

(take-while identity (iterate next [1 2 3 4 5]))

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

(map vector (iterate inc 0) '(1 2 3))

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

(drop 1 (take 3 (map print (iterate inc 0))))

(nil nil)

"012"

(= (take 5 (range)) (take 5 (iterate inc 1)))

false

(nth (iterate #(str % "echo ") "") 20)

"echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo "

(apply (fn [& args] (first args)) (iterate inc 0))

0

(second (iterate #(do (prn %) (inc %)) 0))

1

"0\n"

(= (repeat 100 :foo) (take 100 (iterate identity :foo)))

true

(-> (iterate #(/ % 13) 7)
    (nth 17))

7/8650415919381337933

(binding [*print-level* 3] (print (take 10 (iterate list 1))))

nil

"(1 (1) ((1)) ((#)) ((#)) ((#)) ((#)) ((#)) ((#)) ((#)))"

(def triangles (concat [0] (map + triangles (iterate inc 1))))

#'user/triangles

(take-while #(< % 10) (filter even? (iterate inc 0)))

(0 2 4 6 8)

(def triangles (lazy-cat [0] (map + triangles (iterate inc 1))))

#'user/triangles

(->> 0
     (iterate inc)
     (map int)
     (map type)
     (take 5))

(java.lang.Integer java.lang.Integer
                   java.lang.Integer
                   java.lang.Integer
                   java.lang.Integer)

(let [f (partial + 1)] (take 5 (iterate f 5)))

(5 6 7 8 9)

(defn fp [f n] #(nth (iterate f %) n))

#'user/fp

(let [spinner (iterate not true)] (list (fnext spinner) (fnext spinner)))

(false false)

(def triangles (cons 0 (map + triangles (iterate inc 1))))

#'user/triangles

(nth (iterate #(+ 1 (* 10 %)) 1) 5)

111111

(drop 1 (take 10 (iterate (fn [_] (rand-int 300)) nil)))

(245 277 90 94 147 162 200 262 121)

(def sum (lazy-cat [0] (map + sum (iterate inc 1))))

#'user/sum

(reduce * (reverse (take-while (partial > 10) (iterate inc 1))))

362880

(partition 2 (interleave (iterate inc 0) '(a b c)))

((0 a) (1 b) (2 c))

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

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

(take 5 (apply #(filter odd? %&) (iterate inc 0)))

(1 3 5 7 9)

(map list (iterate inc 0) [1 2 3 4 5])

((0 1) (1 2) (2 3) (3 4) (4 5))

(map count (take 5 (iterate rest [1 2 3 4])))

(4 3 2 1 0)

(take 10 (apply concat [(range 1 5) (iterate inc 1)]))

(1 2 3 4 1 2 3 4 5 6)

(let [n (iterate inc 0)] (= (rest n) (rest n)))

true

(take 5 (iterate butlast [:a :b :c :d :e]))

([:a :b :c :d :e] (:a :b :c :d) (:a :b :c) (:a :b) (:a))

(last (take 5 (iterate #(conj % (rand-int 10)) [])))

[9 8 6 2]

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

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

(for [a (take 4 (iterate inc 0))] (print a))

(nil nil nil nil)

"0123"

(take 3 (filter (partial < 1000) (iterate inc 1)))

(1001 1002 1003)

((fn [[& more]] (take 3 more)) (iterate inc 0))

(0 1 2)