((fn [{:keys [f arg]}] (f arg)) {:arg 41, :f inc})

42

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

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

(let [n (iterate inc 0)] (= (rest n) (rest n)))

true

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

((2 3 4) (3 4 5))

(merge-with (fn [f x] (f x)) {:foo inc} {:foo 1})

{:foo 2}

(apply + (rest (sort (repeatedly 4 #(inc (rand-int 6))))))

12

(for [[a b] (partition 2 (range 10))] [a (inc b)])

([0 2] [2 4] [4 6] [6 8] [8 10])

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

(["a" 1] ["b" 2])

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

((2 0) (2 0))

(every? true? (map = (iterate inc 5) [5 6 7]))

true

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

#'user/make-counter

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

2

(-> {:a {:b {:c [1]}}}
    :a
    :b
    :c
    first
    inc)

2

(clojure.core/seq (clojure.core/concat (clojure.core/list 1)
                                       (clojure.core/list 2)
                                       (map inc [1 2])))

(1 2 2 3)

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

1

(def counter (let [c (atom 0)] (fn [] (swap! c inc))))

#'user/counter

(update-in [{:points {:x 1, :y 2}}] [0 :points :x] inc)

[{:points {:x 2, :y 2}}]

(loop [x 0] (when (< x 10) (recur (inc x))))

nil

(take 10 (map #(str "00" %) (iterate inc 0)))

("000" "001" "002" "003" "004" "005" "006" "007" "008" "009")

(reduce + (rest (sort (repeatedly 4 #(inc (rand-int 6))))))

12

(second (for [x (take 10 (iterate inc 0))] (print x)))

nil

"01"

(nth (iterate #(map inc %) [1 2 3]) 10)

(11 12 13)

(as-> [1 2] x (conj x 3) (map inc x))

(2 3 4)

(update (update {:a 1, :b 2} :a inc) :b dec)

{:a 2, :b 1}

(class (vec (doall (map inc [1 2 3 4 5]))))

clojure.lang.PersistentVector

(map #(inc (int (- (int %) (int \A)))) "ABCDE")

(1 2 3 4 5)

(reduce (fn [c _] (inc c)) 0 [1 2 3])

3

(->> (range 10)
     (filter even?)
     (map inc)
     (reduce + 0))

25

(for [[k v] {:foo 1, :bar 2}] [k (inc v)])

([:foo 2] [:bar 3])

(reduce (fn [acc _] (inc acc)) 0 [1 2 3])

3

(let [x (atom 0) y (swap! x inc)] (class y))

java.lang.Long

(let [a #(first %&)] (apply a (iterate inc 0)))

0

(merge-with (fn [a _] (inc a)) {:a 1} {:a 1})

{:a 2}

(take-while identity (iterate #(if (neg? %) (inc %)) -3))

(-3 -2 -1 0)

(take 4 (filter #(< % 5) (iterate inc 1)))

(1 2 3 4)

(loop [a 0]
  (loop [b 0]
    (print [a b])
    (when (< b 3) (recur (inc b))))
  (when (< a 3) (recur (inc a))))

nil

"[0 0][0 1][0 2][0 3][1 0][1 1][1 2][1 3][2 0][2 1][2 2][2 3][3 0][3 1][3 2][3 3]"

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

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

(for [f [inc dec] num [1 2 3]] (f num))

(2 3 4 0 1 2)

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

2

(transduce (comp (map inc) (filter even?)) + 0 (range 10))

30

(read-string "`(1 2 ~@(map inc [1 2]))")

(clojure.core/sequence
  (clojure.core/seq (clojure.core/concat (clojure.core/list 1)
                                         (clojure.core/list 2)
                                         (map inc [1 2]))))

(->> (range 10)
     (map inc)
     (filter even?)
     (reduce + 0))

30

(def facts (lazy-cat [1] (map * facts (iterate inc 1))))

#'user/facts

(for [x (range 5) item [x (inc x)]] item)

(0 1 1 2 2 3 3 4 4 5)

(defn factorial [number] (reduce * (reverse (range 1 (inc number)))))

#'user/factorial

(let [$ (fn [f x] (f x))] ($ inc 1))

2

(update-in (assoc {:id 2}
             :name "John"
             :age 31)
           [:age]
           inc)

{:age 32, :id 2, :name "John"}

(let [m {:a 1}] (update-in m [:a] (fnil inc 0)))

{:a 2}

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

([:a 2] [:b 3])

(map-indexed #(if (even? %1) (inc %2) %2) (range 10))

(1 1 3 3 5 5 7 7 9 9)