GetClojure

```
(map inc [3 4 5])
```
```
(4 5 6)
```

(take 15 (iterate inc 0))

(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)

```
(map (juxt inc dec) [0])
```
```
([1 -1])
```
```
(update-in {:a 1} [:a] inc)
```
```
{:a 2}
```
```
(defn demo [x] (inc x))
```
```
#'user/demo
```

(some-> nil
        inc
        (+ 3))

nil

```
(-> 1
    (+ 2)
    inc)
```
```
4
```

(take 10 (iterate inc 5))

(5 6 7 8 9 10 11 12 13 14)

(update-in {} [:not-there] (fnil inc 0))

{:not-there 1}

(do (inc 1) "ignored that")

"ignored that"

```
(symbol "(inc amalloy)")
```
```
(inc amalloy)
```
```
(let [loop inc] (loop 1))
```
```
2
```
```
(+ (inc 1) (dec 1))
```
```
2
```

(class (rest (iterate inc 0)))

clojure.lang.Iterate

(class (map inc [1 2]))

clojure.lang.LazySeq

(-> {:foo 1, :bar 2}
    (update-in [:foo] inc)
    (update-in [:bar] inc))

{:bar 3, :foo 2}

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

(2 1 2 1)

(for [a (range 2) c (range (inc a))] [a (inc a) c])

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

```
((fn [x] (inc x)) 1)
```
```
2
```

((partial map inc) (range 10))

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

```
(-> 3
    (* 2)
    (inc))
```
```
7
```
```
(let [->->-> 1] (inc ->->->))
```
```
2
```

(some-> {:a nil}
        :a
        inc)

nil

(ns ... (:refer-clojure :exclude (inc)))

nil

```
(let [$_ 1] (inc $_))
```
```
2
```
```
((fn [f] (f 5)) inc)
```
```
6
```
```
(meta (fn [x] (inc x)))
```
```
nil
```
```
(-> 1
    inc
    (* 3))
```
```
6
```
```
(let [-> inc]
  (-> 5))
```
```
6
```
```
(defn f [x] (inc x))
```
```
#'user/f
```
```
((apply comp [inc dec]) 0)
```
```
0
```
```
(take 4 (iterate inc 0))
```
```
(0 1 2 3)
```

(seque (map inc (range 10)))

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

(take 10 (map inc (range)))

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

(read-string "(inc brehaut)")

(inc brehaut)

```
(read-string "#=(inc 1)")
```
```
2
```

(take 10 (iterate inc 0))

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

(some-> {:a 1}
        :a
        inc)

```
(empty (map inc [1 2]))
```
```
()
```
```
(dotimes [i 100] (inc i))
```
```
nil
```
```
(update-in {:t 4} [:t] inc)
```
```
{:t 5}
```
```
(take 5 (iterate inc 0))
```
```
(0 1 2 3 4)
```
```
(defmacro foo [] `(inc 2))
```
```
#'user/foo
```

(def incs (partial iterate inc))

#'user/incs

```
(def a (iterate inc 0))
```
```
#'user/a
```
```
(meta ^{:a 1} inc)
```
```
nil
```

(->> 5
     range
     second
     inc)

```
(take 4 (iterate inc 8))
```
```
(8 9 10 11)
```

(update-in {:foo 0} [:foo] inc)

{:foo 1}

(doall (map inc (range 500000)))

(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 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127...

<<- <-

9 10 11 12 13 14 15 16 17 18

-> ->>