(take 3 (iterate #(partial (+ % 1)) 0))

(0 1 2)

(map #(take 4 %) [(range) (iterate inc 0)])

((0 1 2 3) (0 1 2 3))

(defn indexed [coll] (map vector (iterate inc 0) coll))

#'user/indexed

(nth (iterate (juxt first rest) '[first rest]) 10)

[first ((((((((((rest))))))))))]

(->> [0 1 2 3]
     (iterate next)
     (take-while some?))

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

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

0

(every? true? (map = (iterate inc 5) [5 6 7]))

true

(take 3 (iterate rest '(:a :b :c :d :e)))

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

((apply hash-map (interleave [:a :b :c] (iterate inc 0))) :b)

1

(-> (iterate #(find % 0) [0 0])
    (nth 1000))

[0 0]

(take 10 (map #(str "00" %) (iterate inc 0)))

("000" "001" "002" "003" "004" "005" "006" "007" "008" "009")

(second (for [x (take 10 (iterate inc 0))] (print x)))

nil

"01"

(for [x (take 5 (iterate butlast "/ab/cd/ef"))] (apply str x))

("/ab/cd/ef" "/ab/cd/e" "/ab/cd/" "/ab/cd" "/ab/c")

(nth (iterate #(map inc %) [1 2 3]) 10)

(11 12 13)

(take-while identity (iterate {:a :b, :b :c, :c :d} :a))

(:a :b :c :d)

(let [a #(first %&)] (apply a (iterate inc 0)))

0

(take-while identity (iterate #(if (neg? %) (inc %)) -3))

(-3 -2 -1 0)

(second (filter identity (iterate #(do (println \.) %) 1)))

1

".\n"

(take 4 (filter #(< % 5) (iterate inc 1)))

(1 2 3 4)

(take 5 (map counted? (iterate #(cons 1 %) nil)))

(false true false false false)

((fn [x]
   (map vector
     (conj (iterate (partial + 10) 11) 0)
     (concat (take-while (partial >= x) (iterate (partial + 10) 10)) [x])))
  55)

([0 10] [11 20] [21 30] [31 40] [41 50] [51 55])

(let [[a & b] (iterate inc 0)] (take 5 b))

(1 2 3 4 5)

(first (for [i (take 10 (iterate inc 0))] (prn i)))

nil

"0\n"

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

(1 2 3 10 11)

(first (map #(do % (print \.)) (iterate inc 1)))

nil

"."

(let [[a b c] (iterate inc 1)] [a b c])

[1 2 3]

(nth (iterate #(map inc %) [1 2 3]) 100)

(101 102 103)

(defn fac [n] (reduce * (take n (iterate inc 1))))

#'user/fac

(take 10 (iterate #(conj % (reduce + %)) [1]))

([1]
 [1 1]
 [1 1 2]
 [1 1 2 4]
 [1 1 2 4 8]
 [1 1 2 4 8 16]
 [1 1 2 4 8 16 32]
 [1 1 2 4 8 16 32 64]
 [1 1 2 4 8 16 32 64 128]
 [1 1 2 4 8 16 32 64 128 256])

(-> (iterate #(*' 2 %) 7)
    (nth 383)
    type)

clojure.lang.BigInt

(take 9 (filter #(< % 10) (iterate inc 1)))

(1 2 3 4 5 6 7 8 9)

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

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

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

2

(take 3 (iterate #(str % " " "hi") "hi"))

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

(def facts (lazy-cat [1] (map * facts (iterate inc 1))))

#'user/facts

(def ts (apply concat (iterate (fn [x] (prn "MOAR")) 2)))

#'user/ts

"\"MOAR\"\n\"MOAR\"\n"

(dorun (take 3 (iterate #(do (println %) %) 3)))

nil

"3\n3\n"

(defn tails [s] (take-while identity (iterate #(subs % 1) s)))

#'user/tails

(take 3 (iterate (fn [x] (concat x (butlast x))) [1 0]))

([1 0] (1 0 1) (1 0 1 1 0))

(reduce :rocks nil (take 15 (iterate (fn [x] {:rocks x}) :rocks)))

:rocks

(reduce :rocks nil (take 16 (iterate (fn [x] {:rocks x}) :rocks)))

{:rocks
   {:rocks
      {:rocks
         {:rocks
            {:rocks
               {:rocks
                  {:rocks
                     {:rocks
                        {:rocks
                           {:rocks {:rocks
                                      {:rocks
                                         {:rocks
                                            {:rocks
                                               {:rocks :rocks}}}}}}}}}}}}}}}

(map (partial take-nth 3) (take 3 (iterate rest (range 12))))

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

(first (filter #(do (println %) true) (iterate inc 0)))

0

"0\n"

(take-while (comp identity seq) (iterate rest [1 2 10 11]))

([1 2 10 11] (2 10 11) (10 11) (11))

(take 10 (reductions :rocks (iterate (fn [x] {:rocks x}) :rocks)))

(:rocks {:rocks :rocks}
        :rocks
        {:rocks {:rocks {:rocks :rocks}}}
        {:rocks {:rocks :rocks}}
        {:rocks :rocks}
        :rocks
        {:rocks {:rocks {:rocks {:rocks {:rocks {:rocks {:rocks :rocks}}}}}}}
        {:rocks {:rocks {:rocks {:rocks {:rocks {:rocks :rocks}}}}}}
        {:rocks {:rocks {:rocks {:rocks {:rocks :rocks}}}}})

(take 5 (iterate (comp :tag meta) '^^^a b c d))

(d c b a nil)

(first (map (fn [x] (println x) x) (iterate inc 0)))

0

"0\n"

(take 4 (map class (iterate #(cons 1 %) nil)))

(nil clojure.lang.PersistentList clojure.lang.Cons clojure.lang.Cons)

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

0

(nth (iterate #(map inc %) [1 2 3]) 1000)

(1001 1002 1003)