(format "%s" (pr-str (map inc [1 2 3])))

"(2 3 4)"

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

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

(map (comp inc val) {:a 0, :b 1})

(1 2)

(defn bla [x] (def y x) (inc x))

#'user/bla

(macroexpand-1 '((-> 1 (fn [x] (inc x)))))

((-> 1
     (fn [x] (inc x))))

(defmacro tester2 [a] `(inc (* ~a 2)))

#'user/tester2

(-> [1 2 3]
    (#(map inc %)))

(2 3 4)

(reduce #(%2 %1) 0 (repeat 1e6 inc))

1000000

(def naturals ((fn [x] (iterate inc x)) 1))

#'user/naturals

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

[1 2]

(macroexpand '((-> 1 (fn [x] (inc x)))))

((-> 1
     (fn [x] (inc x))))

(conj (map inc [2 3 4 5]) 7)

(7 3 4 5 6)

(map #((resolve %) 5) '(inc dec))

(6 4)

(meta (with-meta (fn [a] (inc a)) {:hello :world}))

{:hello :world}

(map deliver [inc dec] [1 2 3 4])

(2 1)

(inc (last (sort (keys {1 2, 3 4}))))

4

(map #(%1 %2) [inc dec] [10 20])

(11 19)

(let [myfun (fn [a] (inc a))] (myfun 42))

43

(for [x [1 2 3 4]] (inc x))

(2 3 4 5)

(reduce (fn [a b] (inc a)) 0 '())

0

((comp (partial apply *) rest range inc) 5)

120

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

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

(update-in [0 0 0 0 0] [2] inc)

[0 0 1 0 0]

(meta (map inc (with-meta (range 10) {:a 0})))

nil

(map inc (drop-last 2 [1 2 3 4]))

(2 3)

(count "(fn [coll] (map inc coll))")

26

(let [f (fn [x] (inc x))] (f 4))

5

(sequence (mapcat (juxt inc identity)) [1 2 3])

(2 1 3 2 4 3)

(reduce (fn [counter _] (inc counter)) 0 [1 2 3])

3

(map (comp eval list) [inc dec] [1 2])

(2 1)

(macroexpand '(if-let [x 1] (inc x) :no-such-thing))

(clojure.core/let [temp__29579__auto__ 1]
  (if temp__29579__auto__
    (clojure.core/let [x temp__29579__auto__] (inc x))
    :no-such-thing))

(take-while #(< % 30) (iterate inc 0))

(0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29)

(update-in (into [] '(1 2 3)) [1] inc)

[1 3 3]

(let [a (atom 5)]
  (swap! a inc)
  @a)

6

(update-in [[1 1] [2 2]] [0 1] inc)

[[1 2] [2 2]]

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

(1 3 5 7 9)

(into {} (for [k (range 6)] [k (inc k)]))

{0 1, 1 2, 2 3, 3 4, 4 5, 5 6}

(interleave (take 10 (iterate inc 1)) (repeat 3))

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

(macroexpand '(pl (↕map range $ 3 inc)))

(pl (↕map range $ 3 inc))

(map #(%2 %1) [1 2] [dec inc])

(0 3)

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

1

(map char (range (int \A) (inc (int \Z))))

(\A \B \C \D \E \F \G \H \I \J \K \L \M \N \O \P \Q \R \S \T \U \V \W \X \Y \Z)

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

nil

"0\n1\n"

(->> (range 100000)
     (map inc)
     (seque)
     (reduce +))

5000050000

(map (fn [i] (inc i)) [1 2 3])

(2 3 4)

(macroexpand (->> (range 5)
                  (map inc)
                  (map dec)))

(0 1 2 3 4)

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

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

(reduce (fn [[i coll] el] (vector (inc i) (conj coll [el (inc i)])))
  [0 []]
  [:a :b :c])

[3 [[:a 1] [:b 2] [:c 3]]]

(reduce into
  []
  [(map char (range (int \A) (inc (int \D))))
   (map char (range (int \a) (inc (int \d))))])

[\A \B \C \D \a \b \c \d]

(letfn [(^:awesome f [x] (inc x))]
  (meta f))

nil