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

"234"

(cond-> 3
  false (* 2)
  true (inc))

4

(format "%s" (doall (map inc (range 5))))

"clojure.lang.LazySeq@1c3e4a2"

(apply list (take 5 (iterate inc 0)))

(0 1 2 3 4)

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

(lazy-seq (cons 1 (inc 1)))

(defn foo [] (let [foo inc] (foo 1)))

#'user/foo

(defn f [x] (* x (inc x)))

#'user/f

(clojure.core/let [G__1263 (inc 10)]
  (println G__1263)
  G__1263)

11

"11\n"

((comp inc {:a 1, :b 2}) :b)

3

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

(2 4)

((fn [{a :a}] (inc a)) {:a 41})

42

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

(2 3 4)

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

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

(assoc (update {:foo 0} :foo inc) :bar 10)

{:bar 10, :foo 1}

(binding [*read-eval* true] (read-string "#=(inc 1)"))

2

(map reduce [inc dec] [0 1] (repeat nil))

(0 1)

(map list [1 2 3] (iterate inc 10))

((1 10) (2 11) (3 12))

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

"redruM"

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

1

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

33

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

(2 3 4)

(update-in {} [:foo] #(if % (inc %) 1))

{:foo 1}

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

[[1 1] [0 1]]

(-> 8
    inc
    dec
    (+ 10)
    (str "foo"))

"18foo"

(let* [a 1]
      (-> 1
          inc
          (* 2)))

4

(zipmap [:a :b :c :d] (iterate inc 0))

{:a 0, :b 1, :c 2, :d 3}

(macroexpand '(for [i (range 3)] (inc i)))

(clojure.core/let [iter__28685__auto__ (clojure.core/fn iter__3284691 [s__3284692] (clojure.core/lazy-seq (loop [s__3284692 s__3284692] (clojure.core/let [s__3284692 (clojure.core/seq s__3284692)] (clojure.core/when s__3284692 (if (clojure.core/chunked-seq? s__3284692) (clojure.core/let [c__28683__auto__ (clojure.core/chunk-first s__3284692) size__28684__auto__ (clojure.core/int (clojure.core/coun...

((resolve (symbol (str "ev" "al"))) '(inc 1))

(inc 1)

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

2

(take-while #(<= % 0) (iterate inc -10))

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

(into {} (for [x (range 3)] [x (inc x)]))

{0 1, 1 2, 2 3}

(defn foo [i] (prn i) (foo (inc i)))

#'user/foo

(reduce (fn [cnt next] (inc cnt)) 0 "foo")

3

(apply sorted-map (interleave (range 10) (iterate inc 100)))

{0 100, 1 101, 2 102, 3 103, 4 104, 5 105, 6 106, 7 107, 8 108, 9 109}

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

2

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

(6 9)

((fn [aseq] (nth aseq 1000000)) (iterate inc 1))

1000001

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

(fn 1 [x] (inc x))

(take 4 (iterate (partial mapv inc) [0 0]))

([0 0] [1 1] [2 2] [3 3])

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

nil

"0\n"

(->> (range)
     (map inc)
     (filter even?)
     (take 5))

(2 4 6 8 10)

(defn foo [] (map #(inc %) (range 3)))

#'user/foo

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

"hello"

(-> 1
    (as-> x (inc x) (dec x)))

1

((fn [x] {:pre [(number? x)]} (inc x)) 1)

2

(map vector [:foo :bar :baz] (iterate inc 0))

([:foo 0] [:bar 1] [:baz 2])

(-> 1
    inc
    (as-> n (* n n)))

4

(take-while #(< % 10) (iterate inc 1))

(1 2 3 4 5 6 7 8 9)

(binding [*read-eval* true] (read-string "#=(inc 54)"))

55

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

(fn x [y] (inc y))