(pr-str (iterate inc 0))

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

(range 5 (inc 15))

(5 6 7 8 9 10 11 12 13 14 15)

(map inc (range 10))

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

(inc (+ 3 2))

6

(defprotocol IncStr
  (inc [s]))

{:methods #{#object
             [clojure.lang.MultiFn 0x4f5991b7 "clojure.lang.MultiFn@4f5991b7"]},
 :name user/IncStr,
 :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"],
 :sigs {:inc {:arglists ([s]), :doc nil, :name inc}}}

(({:t inc} :t) 1)

2

(pr-str (map inc (range)))

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

((comp even? inc) 1)

true

(not (zero? (inc 3)))

true

(hash-map (inc 1) "a")

{2 "a"}

(inc (+ 1 2))

4

(cond-> 42 even? inc)

43

(str (map inc nil))

"clojure.lang.LazySeq@1"

(map inc (range 2))

(1 2)

(cond-> 2 odd? inc)

3

((-> inc
     (partial 1)))

2

(def memoized-inc (memoize inc))

#'user/memoized-inc

(-> [1]
    first
    inc)

2

((:foo {:foo inc}) 1)

2

(sequential? (iterate inc 1))

true

(/ (inc 6) 2)

7/2

(run! inc (range 5))

nil

(take 10 (cycle [inc identity]))

(#object[clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"] #object[clojure.core$identity 0x2af3b054 "clojure.core$identity@2af3b054"] #object[clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"] #object[clojure.core$identity 0x2af3b054 "clojure.core$identity@2af3b054"] #object[clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"] #object[clojure.core$identity 0x2af3b054 "clojure.core...

(def N (iterate inc 0))

#'user/N

((fn [f] (f 1)) inc)

2

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

{:x 1}

(take 4 (iterate inc 1))

(1 2 3 4)

(take 2 (iterate inc 1))

(1 2)

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

(inc 1)

(take 5 (iterate inc 5))

(5 6 7 8 9)

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

2

(= (range) (map inc (range)))

false

(map inc [3 4 5])

(4 5 6)

(take 15 (iterate inc 0))

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

(map (juxt inc dec) [0])

([1 -1])

(+ (inc 10) (dec 10))

20

(map inc (range 1 10))

(2 3 4 5 6 7 8 9 10)

(take 100 (iterate inc 1))

(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
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
 100)

(map inc [3 5 183])

(4 6 184)

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

(clojure.core$inc clojure.lang.Symbol clojure.lang.PersistentList)

(type (map inc (range 5)))

clojure.lang.LazySeq

(update [] 0 (fnil inc 0))

[1]

(let [_ 1] (inc _))

2

(defn- secret-f [x] (inc x))

#'user/secret-f

(pr-str (map inc (range 10)))

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

(map inc [1 2 3])

(2 3 4)

(some-> {:a 0}
        :b
        inc)

nil

(defn whole-numbers [] (iterate inc 0))

#'user/whole-numbers

(update-in {} [\a] (fnil inc 0))

{\a 1}

(println "(inc clgv)")

nil

"(inc clgv)\n"