(last (reductions + (take 10 (iterate inc 1))))

55

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

(* (dec (inc 1)) 10)

((juxt inc dec odd? even? pos? neg?) 12)

[13 11 false true true false]

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

"ij234"

(map (juxt (comp inc rand-int) +) (range 10))

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

(type ((comp (filter odd?) (map inc)) (range 6)))

clojure.core$filter$fn__5958$fn__5959

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

4

(map #(%1 %2) [identity inc] [1 1])

(1 2)

(map (juxt dec identity inc) [-1 0 1])

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

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

(1 2 3 4)

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

1

(into [] (map inc) [1 2 3 4 5])

[2 3 4 5 6]

(zipmap (iterate inc 0) '(a b c))

{0 a, 1 b, 2 c}

(reduce ((map inc) +) '(1 2 3))

8

(into #{} (map inc) #{1 2 3})

#{2 3 4}

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

"foo18"

(reductions #(%2 %1) 0 (repeat 3 inc))

(0 1 2 3)

(reduce #(%2 %1) 1 (repeat 5 inc))

6

(def f (fn f [x] (inc (f x))))

#'user/f

(apply assoc {} (mapcat (juxt identity inc) (range 3)))

{0 1, 1 2, 2 3}

(def triangles (lazy-seq (reductions + (iterate inc 1))))

#'user/triangles

(doall (map inc '(1 2 3 4)))

(2 3 4 5)

(supers (class (map inc (seq (vec (range 100))))))

#{clojure.lang.IHashEq clojure.lang.IMeta clojure.lang.IObj
  clojure.lang.IPending clojure.lang.IPersistentCollection clojure.lang.ISeq
  clojure.lang.Obj clojure.lang.Seqable clojure.lang.Sequential
  java.io.Serializable java.lang.Iterable java.lang.Object java.util.Collection
  java.util.List}

(map class [#(inc %) #{1} #".*"])

(sci.impl.fns$fun$arity_1__26688 clojure.lang.PersistentHashSet
                                 java.util.regex.Pattern)

(last (take 1024 (reductions *' (map inc (range)))))

5418528796058857283076921944683854738001553963538013444482870270683210612073376603733140984136214586719079188457089807539319941657701873682604541333337219391083675280127649937697682925169378911657556806596637479473145184048866776725561251886943352512136772745219634307701337132057962484331288700884361716546902375183904529447322778084029321587220618538061628060639254353108221868482392871302616909142...

(map (partial map inc) (replicate 10 (range 10)))

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

(take 10 (reductions * 1 (iterate inc 1)))

(1 1 2 6 24 120 720 5040 40320 362880)

(dotimes [n 5] (println "(inc weavejester)"))

nil

"(inc weavejester)\n(inc weavejester)\n(inc weavejester)\n(inc weavejester)\n(inc weavejester)\n"

(first (map inc (list 0 1 2 nil)))

1

(map class [5 '5 ''5 inc 'inc ''inc])

(java.lang.Long java.lang.Long
                clojure.lang.PersistentList
                clojure.core$inc
                clojure.lang.Symbol
                clojure.lang.PersistentList)

(let [examplemap {:score 0}] (assoc examplemap :score inc))

{:score #object [clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"]}

(map char (range (int \a) (inc (int \z))))

(\a \b \c \d \e \f \g \h \i \j \k \l \m \n \o \p \q \r \s \t \u \v \w \x \y \z)

((fn [f] (do (println (f 1)) true)) inc)

true

"2\n"

(update-in {:a 0, :b [2]} [:b 0] inc)

{:a 0, :b [3]}

(clojure.core/doseq [sandbox/x (clojure.core/range 9000)]
  (clojure.core/println "(inc clojurebot"))

nil

"(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clojurebot\n(inc clo...

(class (doall (flatten [[(map inc [1 2 3])]])))

clojure.lang.LazySeq

(reduce #(%2 %1) 0 (repeat 3 inc))

3

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

(2 0)

(last (take 50 (reductions *' (map inc (range)))))

30414093201713378043612608166064768844377641568960512000000000000N

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

3

(= (range 20) (take 20 (iterate inc 0)))

true

(map apply [inc dec] [1 2] (repeat nil))

(2 1)

(let [tasks (atom [])] (swap! tasks into [(inc 1)]))

[2]

(dotimes [n 3] (println "(inc cheating)"))

nil

"(inc cheating)\n(inc cheating)\n(inc cheating)\n"

(reduce + (repeatedly 3 #(inc (rand-int 6))))

11

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

(2 3 4)

(let [n 4] (dotimes [n (inc n)] "test"))

nil

(do (def a 1) (alter-var-root #'a inc) a)

2

(defmacro foo [x] `(bar ~(inc x)))

#'user/foo

(map inc (map val {:a 0, :b 1}))

(1 2)