(pr (map inc [1 2 3]))

nil

"(2 3 4)"

(str (mapv inc [1 2 3]))

"[2 3 4]"

(shuffle (take 1000 (iterate inc 7)))

[500 810 343 308 571 123 743 996 375 953 1000 41 144 389 179 756 98 579 447 124 601 622 637 531 477 789 92 861 95 980 195 174 280 64 960 748 814 253 50 728 451 951 598 24 468 941 805 199 543 337 342 995 110 704 421 928 1004 81 787 396 387 749 989 204 367 142 103 406 312 278 695 739 57 586 114 812 713 832 395 184 365 388 977 412 699 573 537 626 595 906 830 645 439 202 173 775 926 557 547 620 346 19...

(realized? (map inc [1 2 3]))

false

(defn f {:meta-attr :fn} [x] (inc))

#'user/f

(-> *
    (#(%))
    inc
    (as-> x (do (def foo x) x))
    inc)

3

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

[2 nil]

(macroexpand '(fn [%] (inc %)))

(fn [%] (inc %))

(macroexpand-1 '(lazy-seq (iterate inc 1)))

(lazy-seq (iterate inc 1))

(type (seq (rest (iterate inc 0))))

clojure.lang.Iterate

(update-in {} ["some string"] (fnil inc 0))

{"some string" 1}

((apply comp (repeat 2 inc)) 5)

7

(for [x (range 10)] (inc x))

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

(let [x 10] `(inc ~x))

(clojure.core/inc 10)

(let [x ^int (inc 5)] x)

6

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

(2 3 4)

(->> (range 10)
     (apply max)
     inc)

10

(map inc (filter odd? (range 10)))

(2 4 6 8 10)

((apply comp (repeat 5 inc)) 0)

5

(-> (range 10)
    ((partial map inc)))

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

((apply comp [not zero? inc]) 3)

true

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

(2 3 4)

(map apply [inc dec] [[1] [1]])

(2 0)

(first (filter even? (iterate inc 1)))

2

(map class [5 '5 inc 'inc])

(java.lang.Long java.lang.Long clojure.core$inc clojure.lang.Symbol)

(((partial partial (comp inc dec)) 5))

5

(= inc #(+ 1 %))

false

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

(1 2 3 4 5)

(map inc '(1 2 3))

(2 3 4)

((comp (partial bit-and 3) inc) -2)

3

(last (take 3 (iterate inc 4)))

6

(defmacro bar [] (seq '[inc 1]))

#'user/bar

(class (fn [^long x] (inc x)))

sci.impl.fns$fun$arity_1__26688

(reduce + ((juxt inc dec) 10))

20

(-> {:a 1}
    (update-in [:a] inc))

{:a 2}

(prn (symbol ",") '(inc chouser))

nil

", ^{:line 1, :column 20} (inc chouser)\n"

(reduce * (range 1 (inc 4)))

24

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

[2 3 4]

(map trampoline [inc dec] [1 2])

(2 1)

(cond-> 3
  false inc
  :else when)

nil

(-> 1
    inc
    ((partial * 3)))

6

(reduce (comp inc +) [1 1])

3

(apply str (map inc (range 5)))

"12345"

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

([2] [3] [4])

(counted? (map inc [1 2 3]))

false

(list (rand-nth '[inc dec]) 'technomancy)

(inc technomancy)

(macroexpand '(-> 1 #(inc)))

(fn* 1 [] (inc))

(let* [x 1 y (inc x)] {})

{}

(mapcat (fn [a b] [(inc a) (inc b)]) [1 2 3] [4 5 6])

(2 5 3 6 4 7)

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

[2 2]