(defn fibs [] (map second (iterate (fn [[x y]] [(+ x y) x]) [1 0])))

#'user/fibs

(take 5 (iterate #(condp = % :a :b :b :c :c :a) :a))

(:a :b :c :a :b)

(def fibs (map second (iterate (fn [[x y]] [y (+ x y)]) [0 1])))

#'user/fibs

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

(1 0 1 1 0 1 1 0 1 0)

(map second (take 15 (iterate (fn [[a b]] [b (+ a b)]) [1 0])))

(0 1 1 2 3 5 8 13 21 34 55 89 144 233 377)

(nth ((fn [] (map first (iterate (fn [[a b]] [b (+ a b)]) [0N 1N])))) 250)

7896325826131730509282738943634332893686268675876375N

(->> [0 1]
     (iterate (fn [[a b]] [b (+ a b)]))
     (map first)
     (take 10))

(0 1 1 2 3 5 8 13 21 34)

(for [x (iterate inc 0) :while (< x 10) y [x] :when (even? y)] y)

(0 2 4 6 8)

(doseq [l (take 10 (iterate #(str % "*") ""))]
  (println (format "%1$30s*%1$s" l)))

nil

"                              *\n                             ***\n                            *****\n                           *******\n                          *********\n                         ***********\n                        *************\n                       ***************\n                      *****************\n                     *******************\n"

(reduce + (map * [3 5 2 1] (iterate #(/ % 10) 0.1M)))

0.3521M

(def very-lazy
  (-> (iterate #(do (print \.) (inc %)) 1)
      rest
      rest
      rest))

#'user/very-lazy

".."

(map first (take 10 (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

(0 1 1 2 3 5 8 13 21 34)

(defn fibo [] (map first (iterate (fn [[a b]] [b (+ a b)]) [0N 1N])))

#'user/fibo

(take 4 (flatten [[1 2 3] [4 5 6] [7 8 (iterate inc 0)]]))

(1 2 3 4)

(take 50 (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

(0
 1
 1
 2
 3
 5
 8
 13
 21
 34
 55
 89
 144
 233
 377
 610
 987
 1597
 2584
 4181
 6765
 10946
 17711
 28657
 46368
 75025
 121393
 196418
 317811
 514229
 832040
 1346269
 2178309
 3524578
 5702887
 9227465
 14930352
 24157817
 39088169
 63245986
 102334155
 165580141
 267914296
 433494437
 701408733
 1134903170
 1836311903
 2971215073
 4807526976
 7778742049)

(take-while not-empty
            (map (partial take 2) (iterate (partial drop 2) [1 2 3 4 5])))

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

((nth (iterate (partial comp next) next) 5) [1 2 3 4 5 6 7 8])

(7 8)

(-> (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1]))
    (nth 40))

102334155

((fn [n] (first (nth (iterate (fn [[x y]] [y (+ x y)]) [0 1]) n))) 6)

8

(let [x (for [x (take 10 (iterate inc 0))] (do (println "Evaling" x) [x]))]
  (first x))

[0]

"Evaling 0\n"

(take 1
      (iterate (comp (partial apply interleave) (partial partition-all 3))
               [1 2 3 4 5 6]))

([1 2 3 4 5 6])

(take 10 (rest (map first (iterate (fn [[a b]] [(+ a b) (inc b)]) [0 1]))))

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

(apply (fn [a b & r] [a b (map identity (take 3 r))]) (iterate inc 0))

[0 1 (2 3 4)]

((fn bit-int [bitseq]
   (apply + (map bit-shift-left (reverse bitseq) (iterate inc 0))))
  [1 0 1 1])

11

(let [f (fn [x & y] (first (drop 1e3 y)))] (apply f (iterate inc 0)))

1001

(let [m {:a :b, :b :c, :c :d}]
  (take-while identity (iterate (partial get m) :a)))

(:a :b :c :d)

(take 10 (map first (iterate (fn [[t n]] [(+ t n) (inc n)]) [1 2])))

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

(map #(vector %1 %2 %3) (iterate inc 0) [:a :b :c] [:a :a :a])

([0 :a :a] [1 :b :a] [2 :c :a])

(def tmp (next (cons 1 (iterate #(do (println (str %1)) (flush) (inc %1)) 1))))

#'user/tmp

(let [nth-arg (fn [n & args] (nth args n))] (apply nth-arg 99 (iterate inc 44)))

143

(first (drop-while #(and (sequential? %) (= 1 (count %)))
                   (iterate first '((((((xz) yz))))))))

((xz) yz)

(doseq [[i e] (map vector (iterate inc 0) '[foo bar baz])] (println i e))

nil

"0 foo\n1 bar\n2 baz\n"

(let [x (iterate inc 0)] (take 10 (concat (take 3 x) [-1] (drop 3 x))))

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

(defn fibo [] 153 (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

#'user/fibo

(vec (mapcat #(if (not= %2 2) (list %1)) [1 2 2 3] (iterate inc 0)))

[1 2 3]

(first (apply concat
         (repeatedly
           (fn [] (do (println "foo") (iterate #(do (println %) (inc %)) 0))))))

0

"foo\nfoo\nfoo\nfoo\n"

(defn get-array-dims
  [a]
  (map count
    (take-while identity (iterate first (make-array Object 1 2 3 4 5)))))

#'user/get-array-dims

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

(1 0 1 0 1 0 1 0 1 0)

(defn maplist
  [f & colls]
  (apply map f (map #(take-while seq (iterate rest %)) colls)))

#'user/maplist

(defn all-positive-ratios [] (iterate #(/ (- (* 2 (- % (rem % 1))) % -1)) 1))

#'user/all-positive-ratios

(take 26
      ((fn [start]
         (filter #(= (seq (str %)) (reverse (str %))) (iterate inc start)))
        0))

(0 1 2 3 4 5 6 7 8 9 11 22 33 44 55 66 77 88 99 101 111 121 131 141 151 161)

(let [xs (lazy-seq (iterate inc 0))
      pre (realized? xs)
      x (first xs)
      post (realized? xs)]
  [pre post])

[false true]

(defn fibber [n] (take n (map first (iterate (fn [[a b]] [b (a + b)]) [0 1]))))

#'user/fibber

(some #(and (= (first %) 'd) %) (iterate next '(a b c d e f)))

(d e f)

(#(mapv (fn [i _] (vec (take i %))) (iterate inc 1) %) [1 2 3 4])

[[1] [1 2] [1 2 3] [1 2 3 4]]

(filter #(= 0 (mod % 3)) (map #(* 2 %) (take 1000 (iterate inc 1))))

(6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 102 108 114 120 126 132 138 144 150 156 162 168 174 180 186 192 198 204 210 216 222 228 234 240 246 252 258 264 270 276 282 288 294 300 306 312 318 324 330 336 342 348 354 360 366 372 378 384 390 396 402 408 414 420 426 432 438 444 450 456 462 468 474 480 486 492 498 504 510 516 522 528 534 540 546 552 558 564 570 576 582 588 594 600 606 612 618 624 ...

(take 20
      (iterate #(->> %
                     -
                     (+ (-> %
                            int
                            (* 2)))
                     inc
                     (/ 1))
               1))

(1 1/2 2N 1/3 3/2 2/3 3N 1/4 4/3 3/5 5/2 2/5 5/3 3/4 4N 1/5 5/4 4/7 7/3 3/8)

(mapcat #(map vector (repeat %) %2) [1 2 3 4] (iterate next [1 2 3 4]))

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

(take 10 (map first (iterate (fn [[rv iv]] [(- iv 2) (* iv 3)]) [:foo 1])))

(:foo -1 1 7 25 79 241 727 2185 6559)

(#(map (fn [i _] (take i %)) (iterate inc 1) %) [1 2 3 4])

((1) (1 2) (1 2 3) (1 2 3 4))