GetClojure

```
((comp inc dec) 1)
```
```
1
```

(class (iterate inc 1))

clojure.lang.Iterate

```
((juxt dec inc) 1)
```
```
[0 2]
```
```
(-> 2
    inc
    dec)
```
```
2
```
```
(map inc '(1))
```
```
(2)
```

(mapv inc (range 10))

[1 2 3 4 5 6 7 8 9 10]

(-> [1 2]
    (->> (map inc)
         (reduce +))
    inc)

(= (-> 3
       inc
       -)
   ((comp - inc) 3))

true

((fn [f] (let [r (f)] (inc r))) (partial inc 2))

```
(-> "hello"
    count
    inc)
```
```
6
```
```
(mapv inc (range 5))
```
```
[1 2 3 4 5]
```

(macroexpand '#(inc 1))

(fn* [] (inc 1))

```
(#(inc %) 1)
```
```
2
```
```
(-> 3
    inc
    dec)
```
```
3
```
```
(doto (inc 3) println)
```
```
4
```
```
"4\n"
```

(hash-map (var inc) "wut")

{#'clojure.core/inc "wut"}

```
((fn inc [] (clojure.core/inc 1)))
```
```
2
```

(println (iterate inc 0))

nil

"(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 ...)\n"

```
(doto (inc 5) println)
```
```
6
```
```
"6\n"
```
```
(inc (doto 2 println))
```
```
3
```
```
"2\n"
```
```
(cond-> 1 true inc)
```
```
2
```

(type '(inc 1))

clojure.lang.PersistentList

```
(macroexpand-1 '(inc 1))
```
```
(inc 1)
```
```
(realized? (iterate inc 0))
```
```
true
```

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

(4 6 10)

```
(let [a 0 b (inc a) b (inc b)] b)
```
```
2
```
```
(let [a 1 a (inc a) a (inc a)] a)
```
```
3
```
```
(let [a 0 b (inc a) c (inc b)] c)
```
```
2
```

(reductions #(conj %1 (%2 (last %1))) [1] [inc inc even?])

([1] [1 2] [1 2 3] [1 2 3 false])

(concat (map inc [1 2 3]) (map inc [6 7 8]))

(2 3 4 7 8 9)

(reduce #(conj %1 (%2 (last %1))) [1] [inc inc even?])

[1 2 3 false]

(let [a 3] `(a ~a (inc a) ~(inc a)))

(user/a 3 (clojure.core/inc user/a) 4)

```
(second (iterate inc 0))
```
```
1
```
```
(doto (inc 1) println)
```
```
2
```
```
"2\n"
```
```
(char (inc (int \A)))
```
```
\B
```
```
(defn x [] (inc 1))
```
```
#'user/x
```
```
(map inc (byte-array 3))
```
```
(1 1 1)
```
```
((fnil inc 1) nil)
```
```
2
```

(class (map inc :foo))

clojure.lang.LazySeq

```
((comp println inc) 1)
```
```
nil
```
```
"2\n"
```
```
(identical? 1 (inc 0))
```
```
true
```
```
(map inc (range 4))
```
```
(1 2 3 4)
```
```
((fnil inc 0) 1)
```
```
2
```

(println '(inc clojurebot))

nil

"(inc clojurebot)\n"

```
(doto (inc 10) println)
```
```
11
```
```
"11\n"
```
```
(#(inc %) 2)
```
```
3
```
```
(eval '(inc 1))
```
```
2
```
```
(#(inc %) 42)
```
```
43
```
```
(swap! (atom 0) inc)
```
```
1
```
```
(map inc [1 2])
```
```
(2 3)
```

<<- <-

6 7 8 9 10 11 12 13 14 15

-> ->>