(sequence (comp (map inc) (map prn)) [1 2 0])

(nil nil nil)

"2\n3\n1\n"

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

[0 [1 0] 2 3]

(transduce (comp (filter odd?) (map inc)) + (range 5))

6

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

(5 6 7)

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

"[\\]^_`abcd"

((#(apply comp (take % (repeat inc))) 20) 22)

42

(defmacro tester [a] `(inc ~(* a 2)))

#'user/tester

(defn s [n] (/ (* n (inc n)) 2))

#'user/s

(do (map inc (lazy-seq (println "foo") '(3))) nil)

nil

(doseq [x '[inc dec]] (println (list x 'amalloy)))

nil

"(inc amalloy)\n(dec amalloy)\n"

(take-while #(< % 10000)
            (map first
              (iterate (fn [[n step]] [(+ n (inc (quot step 20))) (inc step)])
                       [1000 1])))

(1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1021 1023 1025 1027 1029 1031 1033 1035 1037 1039 1041 1043 1045 1047 1049 1051 1053 1055 1057 1059 1062 1065 1068 1071 1074 1077 1080 1083 1086 1089 1092 1095 1098 1101 1104 1107 1110 1113 1116 1119 1123 1127 1131 1135 1139 1143 1147 1151 1155 1159 1163 1167 1171 1175 1179 1183 1187 1191 1195 1199...

(letfn [(foo [n] (lazy-seq (cons n (bar (inc n)))))
        (bar [n] (lazy-seq (cons n (foo (inc n)))))]
  (take 10 (foo 1)))

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

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

nil

(reductions #(%2 %) 1 (take 30 (cycle [inc /])))

(1
 2
 1/2
 3/2
 2/3
 5/3
 3/5
 8/5
 5/8
 13/8
 8/13
 21/13
 13/21
 34/21
 21/34
 55/34
 34/55
 89/55
 55/89
 144/89
 89/144
 233/144
 144/233
 377/233
 233/377
 610/377
 377/610
 987/610
 610/987
 1597/987
 987/1597)

(first (filter #(do (println %) true) (iterate inc 0)))

0

"0\n"

(key (apply max-key (comp inc val) {:a 1, :b 2}))

:b

(update-in [[1 2 3] [4 5 6]] [1 2] inc)

[[1 2 3] [4 5 7]]

(defn new-counter [] (with-local-vars [a 0] (fn [] (var-set a (inc @a)))))

#'user/new-counter

((fn [x]
   (inc x)
   (comment
     "used to return 2x"))
  3)

nil

(defn step [m item] (update-in m [item] (fnil inc 0)))

#'user/step

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

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

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

#'user/new-counter

(-> 5
    inc
    (range)
    (->> (map #(* % 2))))

(0 2 4 6 8 10)

(eduction (comp (map inc) (filter odd?) (partition-all 3)) (range 30))

([1 3 5] [7 9 11] [13 15 17] [19 21 23] [25 27 29])

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

(3 19 10)

(reduce #(%2 %) 1 (take 30 (cycle [inc /])))

987/1597

(into {} (map (juxt inc dec) '(1 2 3 4)))

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

(first (map (fn [x] (println x) x) (iterate inc 0)))

0

"0\n"

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

13

(defn identity' [x] (vary-meta x update :counter (fnil inc 0)))

#'user/identity'

(for [x (range 10) :when (not (odd? x))] (inc x))

(1 3 5 7 9)

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

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

(reduce * (reverse (take-while (partial > 10) (iterate inc 0))))

0

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

(1001 1002 1003)

(->> (* x x)
     (for [x (range 10)])
     (map inc))

(1 2 5 10 17 26 37 50 65 82)

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

(1)

(letfn [(foo [] (bar 1)) (bar [x] (inc x))]
  (foo))

2

(update-in {:foo {:bar {:baz 1}}} [:foo :bar :baz] inc)

{:foo {:bar {:baz 2}}}

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

#'user/lz

((comp #(* 3 %) inc dec dec) 3)

6

(do (ns-unmap *ns* 'map) (map inc [1 2 3]))

(2 3 4)

(apply concat (mapv (juxt dec identity inc) (range 10)))

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

(let [a 0 b (inc a) a 2] b)

1

(doseq [x (map inc [1 2 3 4])] x)

nil

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

2

(for [i (range 5)] (class (/ 4 (inc i))))

(java.lang.Long java.lang.Long
                clojure.lang.Ratio
                java.lang.Long
                clojure.lang.Ratio)

(first (apply (fn [& r] r) (iterate inc 1)))

1

(pr-str (let [x 10 y (inc x)] (fn [] y)))

"#object[sci.impl.fns$fun$arity_0__26683 0xac0127d \"sci.impl.fns$fun$arity_0__26683@ac0127d\"]"

(defmacro n
  [t]
  (println (macroexpand t)
           (-> 1
               inc)))

#'user/n

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

0