(take-while (partial < 1000) (iterate inc 1))

()

(transduce (map inc) conj [] [0 1 2])

[1 2 3]

(format "%s" (pr-str (map inc (range 5))))

"(1 2 3 4 5)"

(apply + (take 10 (iterate inc 0)))

45

(letfn [(foo [x] (inc x))]
  (foo 4))

5

(macroexpand '(future (Thread/sleep 5000) (inc 1)))

(future (Thread/sleep 5000) (inc 1))

(defmacro foo [] (inc 1 2 3 4))

#'user/foo

((fn [x] (vector 'x) (inc x)) 1)

2

(let [r (atom 0)] (swap! r inc))

1

(->> 1
     inc
     (repeat 2)
     (apply *))

4

(defmacro inc-it [] `(dosync (commute ~'it inc)))

#'user/inc-it

(let [f 1] (macroexpand-1 `(inc f)))

(clojure.core/inc user/f)

(def a (map inc [1 2 3]))

#'user/a

(str (doall (map inc [1 2 3])))

"clojure.lang.LazySeq@7c42"

(defn print-tree
  [t depth]
  (when (:left t)
    (print-tree (:left t) (inc depth))
    (print-tree (:right t) (inc depth))))

#'user/print-tree

(let [{:keys [a b], :as m} {:a 1, :b 2} c (inc a) d (inc c)] d)

3

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

5000050000

(update-in {:value 100} [:value] (fnil inc 0))

{:value 101}

(= [1 2 3] (iterate inc 1))

false

(eval '(map inc [1 2 3]))

(2 3 4)

(map (juxt - inc) [1 2 3])

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

(into #{} (map inc) [0 1 2])

#{1 2 3}

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

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

(map (fnil inc 1) [2 nil 0])

(3 2 1)

(reduce + (map inc [1 2 3]))

9

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

2

(take 10 (cons 0 (iterate inc 1)))

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

(* (clojure.core/-> (clojure.core/-> 1
                                     inc)
                    dec)
   10)

10

(defn f2 ^long [^long x] (inc x))

#'user/f2

(reduce * (take 5 (iterate inc 1)))

120

(defn whatever [#^String x] (println (inc x)))

#'user/whatever

(update-in {:a 1, :b 2} [:a] inc)

{:a 2, :b 2}

(map inc '(1 2 3 4))

(2 3 4 5)

(chunked-seq? (seq (map inc (vec (range 100)))))

true

(let [{:strs [a]} {"a" 41}] (inc a))

42

((comp (partial take 10) iterate) inc 0)

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

(reduce +
  (clojure.core/->> (range 10)
                    (map inc)))

55

(type (sequence (map inc) [1 2 3]))

clojure.lang.LazySeq

(mapv inc [1 2 3 4 5])

[2 3 4 5 6]

(for [myfn '(inc dec)] (myfn 1))

(nil nil)

(->> (range 10)
     (filter even?)
     (map inc))

(1 3 5 7 9)

(-> 30
    (range)
    (distinct)
    (->> (map inc)))

(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
 30)

(take 1 (map println (iterate inc 0)))

(nil)

"0\n"

(let [x 1 x (inc x)] x)

2

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

(2 1 3 2 4 3)

(class (flatten [[(map inc [1 2 3])]]))

clojure.lang.LazySeq

(doall (map inc [1 2 3 4]))

(2 3 4 5)

(let [fs (juxt inc dec)] (fs 1))

[2 0]

(take (- 10 -20) (iterate inc -20))

(-20
 -19
 -18
 -17
 -16
 -15
 -14
 -13
 -12
 -11
 -10
 -9
 -8
 -7
 -6
 -5
 -4
 -3
 -2
 -1
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9)

(dotimes [_ 3] (println '(inc hyPiRion)))

nil

"(inc hyPiRion)\n(inc hyPiRion)\n(inc hyPiRion)\n"