GetClojure

```
(let [inc #(+ % 10)] (inc 2))
```
```
12
```

(let [inc #(+ %10)] `(inc 2))

(clojure.core/inc 2)

(reduce #(%2 %1) 0 [inc inc dec dec])

(let [x (gensym)] `[(inc ~x) `(inc ~~x)])

[(clojure.core/inc G__3087823)
 (clojure.core/sequence
   (clojure.core/seq (clojure.core/concat (clojure.core/list
                                            (quote clojure.core/inc))
                                          (clojure.core/list G__3087823))))]

```
(doto 1 inc)
```
```
1
```
```
(deliver inc 3)
```
```
4
```
```
(:name (meta inc))
```
```
nil
```
```
(some-> 0
        inc)
```
```
1
```
```
(->> 1
     inc)
```
```
2
```
```
(map inc [0])
```
```
(1)
```
```
((cat inc)
  1)
```
```
2
```

(type (inc Integer/MAX_VALUE))

java.lang.Long

```
(def inc clojure.core/inc)
```
```
#'user/inc
```
```
(-> 5
    (inc))
```
```
6
```
```
(inc (dec 1))
```
```
1
```
```
((var inc) 1)
```
```
2
```
```
(-> 0
    inc)
```
```
1
```

((reduce (fn [f1 f2] (fn [& args] (f1 (apply f2 args)))) [inc inc inc]) 1)

```
(let [x 10 x (inc x) x (inc x)] x)
```
```
12
```
```
(let [x 1 x (inc x) x (inc x)] x)
```
```
3
```

(-> *
    (#(%))
    inc
    (doto (->> (def foo)))
    inc)

(take 10 (map vector (iterate inc 1) (iterate inc 2)))

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

(map apply [inc inc dec] (map list [3 5 11]))

(4 6 10)

(-> *
    (#(%))
    inc
    (->> (def foo)
         deref)
    inc)

(-> 7
    inc
    dec
    (as-> y (+ y y))
    inc)

(str (map inc [1]))

"clojure.lang.LazySeq@21"

```
(counted? (iterate inc 0))
```
```
false
```
```
(map inc [1336 41])
```
```
(1337 42)
```
```
(cond-> 2 even? inc)
```
```
3
```
```
(def xf (map inc))
```
```
#'user/xf
```
```
(((partial partial inc) 5))
```
```
6
```

(inc (+ 1 Integer/MAX_VALUE))

2147483649

```
(inc (get {} :test 0))
```
```
1
```
```
(seq? (iterate inc 0))
```
```
true
```
```
(mapv inc [0 1])
```
```
[1 2]
```
```
((comp inc -) 2)
```
```
-1
```

(class (comp inc dec))

clojure.core$comp$fn__5876

((juxt [inc dec]) 1)

[#object [clojure.core$dec 0x7ae92de2 "clojure.core$dec@7ae92de2"]]

```
(def a (map inc))
```
```
#'user/a
```
```
(sequential? (iterate inc 0))
```
```
true
```
```
(inc (* 3 4))
```
```
13
```
```
(eval '(inc 5))
```
```
6
```
```
(realized? (map inc (range)))
```
```
false
```
```
(chunked-seq? (map inc (range)))
```
```
false
```
```
(swap! (atom 1) inc)
```
```
2
```

(class (iterate inc 1))

clojure.lang.Iterate

```
((juxt dec inc) 1)
```
```
[0 2]
```
```
(->> 1
     inc
     dec)
```
```
1
```
```
((juxt inc dec) 41)
```
```
[42 40]
```
```
(second (iterate inc 1))
```
```
2
```

<<- <-

5 6 7 8 9 10 11 12 13 14

-> ->>