(reduce (fn [c x] (conj c (inc x))) () (range 10))

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

(map (comp inc :foo) [{:foo 10, :bar 1} {:foo 1}])

(11 2)

(map deliver (cycle [inc dec]) [1 2 3 3 4])

(2 1 4 2 5)

(map (juxt inc dec #(* 3 %)) (range 4))

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

(def x
  #(-> %
       (+ 3)
       (/ 2)
       inc))

#'user/x

(map #(%1 %2) [reverse inc dec] ["hi" 4 5])

((\i \h) 5 4)

(let [a 1 b (inc a)] {:a a, :b b})

{:a 1, :b 2}

(mapcat #(list % (inc %)) [2 4 6 8])

(2 3 4 5 6 7 8 9)

(def make-id (let [a (atom 0)] (fn [] (swap! a inc))))

#'user/make-id

(->> (range 90 100)
     (map inc)
     (map char)
     (apply str))

"[\\]^_`abcd"

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

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

(defn f
  [ind inds]
  (if (= ind (first inds))
    (cons 1 (lazy-seq (f (inc ind) (rest inds))))
    (cons 0 (lazy-seq (f (inc ind) inds)))))

#'user/f

(concat '(1 2 3 4) (take 5 (iterate inc 5)))

(1 2 3 4 5 6 7 8 9)

(vec (map #(update-in % [0] inc) [[0 :a] [1 :b]]))

[[1 :a] [2 :b]]

(loop [a 1] (if (< a 3) (recur (inc a)) a))

3

(let [x [1 2 3 4]] (zipmap x (map inc x)))

{1 2, 2 3, 3 4, 4 5}

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

[189519051 2 189519051]

(apply hash-map (flatten (map (fn [k] [k (inc k)]) (range 6))))

{0 1, 1 2, 2 3, 3 4, 4 5, 5 6}

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

(1 2 2 3 3 4)

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

(2 3 4 5)

(map (juxt class ifn?) [inc [] (symbol "foo") :foo "str" #"re" {} #{} ()])

([clojure.core$inc true]
 [clojure.lang.PersistentVector true]
 [clojure.lang.Symbol true]
 [clojure.lang.Keyword true]
 [java.lang.String false]
 [java.util.regex.Pattern false]
 [clojure.lang.PersistentArrayMap true]
 [clojure.lang.PersistentHashSet true]
 [clojure.lang.PersistentList$EmptyList false])

(let [^long x 1] ((fn ^long [^long n] (inc n)) x))

2

(defn fire-x-times [x] (dotimes [n x] (println "fired" (inc n) "times")))

#'user/fire-x-times

(into {} (for [[k v] {:a 1, :b 2}] [k (inc v)]))

{:a 2, :b 3}

((fn [i] (for [j i] (do (inc j)))) [1 2 3])

(2 3 4)

(as-> 1 ☕ (inc ☕) (* ☕ 3) [☕ ☕ ☕])

[6 6 6]

(first (apply concat (repeatedly #(do (println "foo") (iterate inc 0)))))

0

"foo\nfoo\nfoo\nfoo\n"

(let [m {:a 1}] (zipmap (keys m) (map inc (vals m))))

{:a 2}

(for [[k v] {:a 0, :b 1, :c 2}] (inc v))

(1 2 3)

(map #(inc (quot (dec %) 25)) [1 24 25 100])

(1 1 1 4)

(map #(prn %1 %2) [:a :b :c] (iterate inc 0))

(nil nil nil)

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

(let [s "12/34/900" ofs (.lastIndexOf s "/")] (subs s (inc ofs)))

"900"

(clojure.string/replace "test" #"s" (fn [m] (str (char (inc (int (first m)))))))

"tett"

(map #(juxt inc dec %) [1 2 3 4 5])

(#object[clojure.core$juxt$fn__5893 0x38ebf96b "clojure.core$juxt$fn__5893@38ebf96b"] #object[clojure.core$juxt$fn__5893 0x362c1006 "clojure.core$juxt$fn__5893@362c1006"] #object[clojure.core$juxt$fn__5893 0x3213921b "clojure.core$juxt$fn__5893@3213921b"] #object[clojure.core$juxt$fn__5893 0x77111a3d "clojure.core$juxt$fn__5893@77111a3d"] #object[clojure.core$juxt$fn__5893 0x10d69515 "clojure.core...

(defn count-larger? [coll n] (> (count (take (inc n) coll)) n))

#'user/count-larger?

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

[2 1]

(loop [i 0] (if (= i 7) i (recur (inc i))))

7

(find (apply hash-map (interleave [:a :b :c] (iterate inc 0))) :b)

[:b 1]

(map #(into [] %) (partition 3 (take 9 (iterate inc 1))))

([1 2 3] [4 5 6] [7 8 9])

(transduce (comp (map inc) (filter even?) (take 5)) conj [] (range))

[2 4 6 8 10]

((fn [n]
   (-> n
       ((if (even? n) identity inc))))
  3)

4

(let [[a & b] (iterate inc 0)] (take 5 b))

(1 2 3 4 5)

(map #(% 1) [inc dec #(+ 2 %)])

(2 0 3)

(macroexpand '(defn foo [& args] (foo (alter-var-root! foo inc))))

(defn foo [& args] (foo (alter-var-root! foo inc)))

(defn next-po10 [n] (* 10 (inc (int (/ n 10)))))

#'user/next-po10

(update-in {:a 1} [:b] (comp inc #(or % 0)))

{:a 1, :b 1}

(first (for [i (take 10 (iterate inc 0))] (prn i)))

nil

"0\n"

(eval '(doall (for [i [1 2 3]] (inc i))))

(2 3 4)

(take 5 (apply concat [[1 2 3] (iterate inc 10)]))

(1 2 3 10 11)

(when-let [x (not-empty #{1 2 3})] (map inc x))

(2 4 3)