(let [f (partial apply vector)]
  (-> [1 2 3]
      reverse
      f))

[3 2 1]

(let [[& [a b c]] [1 2]] (list a b c))

(1 2 nil)

(let [s (range 2)] (for [i s j s] [i j]))

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

(let [a 1 b 2 c "hello"] '[a b c])

[a b c]

(let [x (transient [])]
  (dotimes [n 100] (conj! x n))
  (persistent! x))

[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 99]

(let [u (apply sorted-set (range 17))] (get u (rand-int (count u))))

4

(let [{:keys [foo bar], :or {:foo 1}} {:bar 5}] [foo bar])

[nil 5]

(let [{:syms [a b]} {'a 1, 'b 2}] (list a b))

(1 2)

(defn who-cares
  []
  (let [s (gensym)]
    (intern *ns* s)
    @(resolve s)))

#'user/who-cares

(let [f (fn [& {a :a}] (inc a))] (f :a 10))

11

(let [f1 #(inc %)] (defmacro m1 [x] `(~f1 ~x)))

#'user/m1

(let [m (transient {1 2})] [(get m 1) (contains? m 1)])

[2 true]

(let [{a 1, b 2} [1 2 3 4]] [a b])

[2 3]

(let [ext "xls"]
  (clojure.string/replace "test.xls" (re-pattern (str "\\." ext "$")) ".html"))

"test.html"

(let [a [5] b [5]] [(identical? a b) (set [a b])])

[false #{[5]}]

(let [a 1] (some #(= % a) [2 3 1]))

true

(let [{i :foo} {:foo {:bar 1, :baz 2}} output-val [i]] output-val)

[{:bar 1, :baz 2}]

(let [[first more] [:name [:first-name :last-name]]] (for [x more] [first x]))

([:name :first-name] [:name :last-name])

(let [some-data [(range 10) (range 30 50)]] (apply map + some-data))

(30 32 34 36 38 40 42 44 46 48)

(let [some-symbol (symbol "I worship His Shadow")]
  (print (list '+ some-symbol)))

nil

"(+ I worship His Shadow)"

(let [L (with-meta '(a b) {:foo :bar})] (meta (pop L)))

nil

(defmacro implicitly-bind-foo [[s] & body] `(let [~'x (:x ~s)] ~@body))

#'user/implicitly-bind-foo

(do (let [a (atom 0)] (defn make-id [] (swap! a inc))) (make-id))

1

(let [v (vector 1 2) [x y] v] (+ x y))

3

(let [[last-2 last-1 last] (take-last 3 (range 100))] [last-2 last-1 last])

[97 98 99]

(let [[a & x] (seq {:a 1, :b 1})] [a x])

[[:a 1] ([:b 1])]

(let [[x & xs] [1 1 1]] (every? #{x} xs))

true

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

1000

(let [the-map {:fn #(inc %)}]
  (-> the-map
      :fn
      (deliver 5)))

6

(let [coll [1 2 3]] (into (empty coll) (map inc coll)))

[2 3 4]

(let [x (double 1/6)] (+ x x x x x x))

1.0000000000000002

(let [s1 [1 2] s2 [1 2]] (identical? s1 s2))

false

(let [r (range 7)] (map (partial take-nth 2) [r (rest r)]))

((0 2 4 6) (1 3 5))

(let [a {:a 1}] (zipmap (keys a) (map inc (vals a))))

{:a 2}

(let [[a b c] [1 2 3 4]] [a b c])

[1 2 3]

(defmacro cl-let [argvec & body] `(let ~(vec argvec) ~@body))

#'user/cl-let

(defmacro bar
  [m & body]
  (let [lala (mapcat (fn [[k v]] [(with-meta (symbol (name k))
                                    {:tag (class (eval v))}) v])
               m)]
    `(let [~@lala] ~@body)))

#'user/bar

(let [bit-racket (fn [data]
                   (let [d (atom data)]
                     (fn [n]
                       (let [r (take n @d)]
                         (swap! d #(drop n %))
                         r))))
      b (bit-racket "ABCDEFG")]
  (println (b 2))
  (println (b 1))
  (println (b 4))
  (println (b 5)))

nil

"(A B)\n(C)\n(D E F G)\n()\n"

(let [f #(* % %)
      g (fn [f x]
          (let [a (f x)]
            (println x a)
            a))]
  (map #(g f %) (range 5)))

(0 1 4 9 16)

"0 0\n1 1\n2 4\n3 9\n4 16\n"

(let [r (reduce concat (repeat 1e5 '(1)))] (+ 2 2))

4

(let [a 3 b 4] `(~(+ a b) c))

(7 user/c)

(let [s (pr-str {:a 1, :b 2})]
  (println s)
  (read-string s))

{:a 1, :b 2}

"{:a 1, :b 2}\n"

(let [{truthy true, falsey false} (group-by even? (range 20))] [truthy falsey])

[[0 2 4 6 8 10 12 14 16 18] [1 3 5 7 9 11 13 15 17 19]]

(let [x 3]
  (clojure.core/apply clojure.core/hash-map
    (clojure.core/seq (clojure.core/concat (clojure.core/list :a)
                                           (clojure.core/list x)))))

{:a 3}

(let [{:strs [a b]} {"a" 5, "b" 6}] (+ a b))

11

(let [hello (fn [who] (str "Hello, " who "!"))] (hello "Neo"))

"Hello, Neo!"

(defn kqk [& body] `(let [~'K "king" ~'Q "queen"] ~@body))

#'user/kqk

(let [ns (ns-name *ns*)]
  (in-ns 'test)
  (def x 42)
  (in-ns ns))

nil

(let [x [1 2 3]]
  (for [i x] (println i))
  1)

1

(let [a (repeatedly 2 #(transient []))] (identical? (first a) (second a)))

false