(let [i 0] (dotimes [_ 350] (inc i)))

nil

(apply str (map (comp char inc int) "hello"))

"ifmmp"

(map prn [:a :b :c] (iterate inc 0))

(nil nil nil)

":a 0\n:b 1\n:c 2\n"

(let [inc #(+ % 10)] (clojure.core/inc 2))

3

(let [f (comp inc +)] (f 5 6))

12

(dotimes [i 10] (println "(inc clojure)"))

nil

"(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n(inc clojure)\n"

(update-in {:x [{:y 1}]} [:x 0 :y] inc)

{:x [{:y 2}]}

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

2

(#(% %3 %2) map (range 10) inc)

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

(take 5 (repeatedly (partial swap! (atom 0) inc)))

(1 2 3 4 5)

(map (comp inc first) (replicate 3 (range 3)))

(1 1 1)

(defmacro run [expr] `(inc ~(eval expr)))

#'user/run

(reduce + (map inc (filter even? (range 10000))))

25000000

(-> 5
    inc
    (* 4 (+ 2 7)))

216

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

(2 3 4)

(map inc [1 4 7 10 13 16])

(2 5 8 11 14 17)

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

nil

"0\n"

(into [] (map inc [1 2 3 4 5]))

[2 3 4 5 6]

(map inc (sorted-set 1 2 3 0 -1))

(0 1 2 3 4)

(read-string "#=(map inc [1 2 3])")

(2 3 4)

(= (map inc (range 10)) (range 1 11))

true

(reduce ((map inc) +) 0 [4 5 6])

18

(clojure.walk/macroexpand-all '(-> 1 inc dec (* 10)))

(* (dec (inc 1)) 10)

(into {} (map (juxt identity inc) [1 2 3]))

{1 2, 2 3, 3 4}

((juxt inc dec #(+ 10 %)) 10)

[11 9 20]

(format "%s" (apply str (map inc (range 5))))

"12345"

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

((2 3) (4 5))

(map #(% %2) [inc dec] [10 11])

(11 10)

(for [i [1 2 3]] [i (inc i)])

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

(do (def a 3) (alter-var-root #'a inc) a)

4

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

(nil nil)

"nil\nnil\n"

(apply str (map (comp char inc int) "HAL"))

"IBM"

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

6

(map #(meta (resolve %)) '[inc dec])

({:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name inc, :sci/built-in true, :arglists ([x]), :doc "Returns a number one greater than num. Does not auto-promote\n  longs, will throw on overflow. See also: inc'", :sci.impl/inlined #object[clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"]} {:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name dec, :s...

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

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

(reduce #(%2 %1) 1 (repeat 1000000 inc))

1000001

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

9

((fn f [{:keys [a]}] (inc a)) {:a 1})

2

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

43

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

((2 3) (4 5))

(into '() (map inc '(1 2 3)))

(4 3 2)

(let [foo (gensym)] `(fn [~foo] (inc ~foo)))

(clojure.core/fn [G__3036902] (clojure.core/inc G__3036902))

((juxt class (comp class rest)) (iterate inc 1))

[clojure.lang.Iterate clojure.lang.Iterate]

(defn F [n] (cons n (F (inc n))))

#'user/F

((fn [[_ a]] (inc a)) (list 10 11))

12

(let [a 0
      b (inc a)
      c (inc b)]
  (print a b c)
  (print a b)
  (print a))

nil

"0 1 20 10"

(let [i (let [k (int 0)] k)] (inc i))

1

(macroexpand '(#(map inc %&) 1 2 3))

((fn* [& %&] (map inc %&)) 1 2 3)

(defn ! [n] (reduce * (range 1 (inc n))))

#'user/!

(into {} (for [x (range 0 10)] [x (inc x)]))

{0 1, 1 2, 2 3, 3 4, 4 5, 5 6, 6 7, 7 8, 8 9, 9 10}