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

([2 0] [3 1] [4 2] [5 3] [6 4])

(defn factorial-m [n] (reduce *' (range 1 (inc n))))

#'user/factorial-m

(update-in {:a [0 1 2 3]} [:a 2] inc)

{:a [0 1 3 3]}

(let [[bigger smaller] ((juxt inc dec) 10)] [bigger smaller])

[11 9]

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

(9 2 3 4)

(defn lazy-next [i] (lazy-seq (cons i (lazy-next (inc i)))))

#'user/lazy-next

(->> (iterate inc 1)
     (map + (range))
     (take 5))

(1 3 5 7 9)

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

1

(reduce (fn [i _] (inc i)) 0 "Hello World")

11

(macroexpand '(->> (range 5) (map inc) (map dec)))

(map dec (map inc (range 5)))

(into {} (for [x [1 2 3]] [x (inc x)]))

{1 2, 2 3, 3 4}

(let [count (atom 0)] (defn counter [] (swap! count inc)))

#'user/counter

((apply juxt [inc dec #(+ % 10)]) 0)

[1 -1 10]

(map inc (drop-last 2 '(1 2 3 4)))

(2 3)

(do (println "add me to this result") (inc 1))

2

"add me to this result\n"

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

"23456"

(let [the-map {:atom (atom 1)}] (swap! (:atom the-map) inc))

2

(swap! (atom {:a {:b 0}}) update-in [:a :b] inc)

{:a {:b 1}}

(map (partial map inc) [(range 10) (range 20 30)])

((1 2 3 4 5 6 7 8 9 10) (21 22 23 24 25 26 27 28 29 30))

(transduce (map inc) + 0 [1 2 3 4])

14

(defn finc [c] (into (empty c) (map inc c)))

#'user/finc

(chunked-seq? (concat (map inc [1 2 3 4 5])))

false

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

(partial (dec (inc 1)) * 10)

(update-in {:x 1} [:x] #(and % (inc %)))

{:x 2}

(map #(take %1 (iterate inc %1)) (range 5))

(() (1) (2 3) (3 4 5) (4 5 6 7))

(map vector (iterate inc 0) '(1 2 3))

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

(drop 1 (take 3 (map print (iterate inc 0))))

(nil nil)

"012"

(defn lz [i] (cons i (lazy-seq (lz (inc i)))))

#'user/lz

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

{1 2, 2 3, 3 4}

(= (take 5 (range)) (take 5 (iterate inc 1)))

false

(update-in {:a1 42, :a2 {:b1 420}} [:a2 :b1] inc)

{:a1 42, :a2 {:b1 421}}

(->> (range 16)
     (map inc)
     (partition 4)
     (partition 2))

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

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

(3 5 7)

(macroexpand '(-> 1 inc dec (partial * 10)))

(partial (dec (inc 1)) * 10)

(apply (fn [& args] (first args)) (iterate inc 0))

0

(defn forever [start] (lazy-seq (cons start (forever (inc start)))))

#'user/forever

(into {} (map (juxt key (comp inc val))) {:a 1})

{:a 2}

(clojure.string/replace "test" #"s" (comp str char inc int first))

"tett"

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

{:bar 10, :foo 1}

(defn foo [] (lazy-seq (loop [n 0] (recur (inc n)))))

#'user/foo

(let [a (atom 0)] (defn inc-counter [] (swap! a inc)))

#'user/inc-counter

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

#'user/next-po10

(reduce + 0 (map inc (filter even? (range 1000000))))

250000000000

(second (iterate #(do (prn %) (inc %)) 0))

1

"0\n"

(let [ctr (atom 0)] (defn counter [] (swap! counter inc)))

#'user/counter

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

nil

"2"

(tree-seq #(< % 10) (comp list inc) 0)

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

(map #(% 1) ((juxt juxt juxt) inc dec))

([2 0] [2 0])

(let [x (resolve 'a)] (def f (fn [] (inc @x))))

#'user/f

(apply concat (for [i (range 10)] [i (inc i)]))

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