GetClojure

```
(print "(inc devn)")
```
```
nil
```
```
"(inc devn)"
```
```
(-> 1
    inc
    (* 2))
```
```
4
```
```
(let [x (inc 1)] x)
```
```
2
```
```
(let [foo# 34] (inc foo#))
```
```
35
```

(print "(inc clojurebot)")

nil

"(inc clojurebot)"

```
(let [++ inc] (++ 1))
```
```
2
```

(read-string "#(inc %)")

(fn* [%1] (inc %1))

```
(let [_1+ inc] (_1+ 7))
```
```
8
```
```
(inc ({2 1} 2 0))
```
```
2
```
```
(macroexpand '(-> 1 inc))
```
```
(inc 1)
```
```
((juxt dec identity inc) 0)
```
```
[-1 0 1]
```

(into [] (map inc) (range 10))

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

```
(defn foo [x] (inc x))
```
```
#'user/foo
```

(do (def f inc) (def g inc) (def h (comp #'f #'g)))

#'user/h

(map apply [inc dec] ((juxt (comp vector inc) (comp vector dec)) 0))

(2 -2)

(defn foo [] (let [inc #(+ 3 %1)] (map inc (range 3))))

#'user/foo

(take 10 (map #(/ (* % (inc %)) 2) (iterate inc 0)))

(0 1 3 6 10 15 21 28 36 45)

```
(some-> 1
        inc
        (+ 3))
```
```
5
```
```
(map inc (repeat 5 2))
```
```
(3 3 3 3 3)
```
```
(update {:a 1} :a inc)
```
```
{:a 2}
```

(realized? (next (iterate inc 1)))

false

(defn whole-numbers [] (iterate inc 1))

#'user/whole-numbers

(defmacro foo [] (seq [inc 1]))

#'user/foo

```
((comp first (juxt inc)) 1)
```
```
2
```

(macroexpand-1 '(clojure.core/-> 1 inc))

(inc 1)

```
(let* [x 12] (inc x))
```
```
13
```
```
(let [do inc] (do 1))
```
```
1
```

(prn-str (map inc (range 10)))

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

```
((fn [世界] (inc 世界)) 1)
```
```
2
```
```
(-> 5
    #_whatever
    inc)
```
```
6
```

(read-string "#(inc 1)")

(fn* [] (inc 1))

```
(mapv inc [1 2 3])
```
```
[2 3 4]
```
```
(map inc (range 0 3))
```
```
(1 2 3)
```

(into [] (map inc) (range 5))

[1 2 3 4 5]

```
(nth (iterate inc 0) 5)
```
```
5
```
```
((partial + (inc 1)) 2)
```
```
4
```
```
((comp inc :foo) {:foo 3})
```
```
4
```
```
(((partial juxt inc) dec) 5)
```
```
[6 4]
```

(str (map inc (range 10)))

"clojure.lang.LazySeq@c5d38b66"

(into () (map inc) (range 5))

(5 4 3 2 1)

(drop (inc 0) (range 10))

(1 2 3 4 5 6 7 8 9)

(map inc (vec (range 10)))

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

```
(* (dec (inc 1)) 10)
```
```
10
```

(pr-str (map inc (range 5)))

"(1 2 3 4 5)"

```
(symbol "(inc brehaut)")
```
```
(inc brehaut)
```

(prn (map inc (range 10)))

nil

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

```
((comp inc +) 1 1)
```
```
3
```
```
(every? inc [1 2 3])
```
```
true
```

(take 100 (iterate inc 0))

(take 4 (cycle [inc identity]))

(#object [clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"]
 #object [clojure.core$identity 0x2af3b054 "clojure.core$identity@2af3b054"]
 #object [clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"]
 #object [clojure.core$identity 0x2af3b054 "clojure.core$identity@2af3b054"])

<<- <-

10 11 12 13 14 15 16 17 18 19

-> ->>