(macroexpand `(let [~'+ -] (~'+ 1 1)))

(clojure.core/let [+ clojure.core/-] (+ 1 1))

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

[1 2]

(let [[a b :as x] [1 2]] b)

2

(let [x map] (x inc [1 2 3]))

(2 3 4)

(macroexpand '(let [x# 1 x# 2] x#))

(let [x# 1 x# 2] x#)

(let [x 3 x (+ x 3)] x)

6

(let [m {:a 1} {:keys [a]} m] a)

1

(defmacro frob [form] `(let [a# "dog"] (~form)))

#'user/frob

(-> '(let [a 1])
    second
    first
    meta)

nil

(let [n 4] (dotimes [n (inc n)] "test"))

nil

(let [x '(1 2 3)] `(~@x))

(1 2 3)

(let [x 1
      f (fn [] x)]
  (f)
  (f))

1

(defmacro m [exp] `(let [x 1] ~exp))

#'user/m

(let [{:as map} [[:a 1] [:b 2]]] map)

[[:a 1] [:b 2]]

(let [cookie "abc"] (str "<logout cookie=\"" cookie "\"/>"))

"<logout cookie=\"abc\"/>"

(let [i 0] (dotimes [_ 350] (inc i)))

nil

(defmacro my-try [& args] (let [thing# args] thing#))

#'user/my-try

(let [inc #(+ % 10)] (clojure.core/inc 2))

3

(let [f (comp inc +)] (f 5 6))

12

(let [{:as map} [:a 1 :b 2]] map)

[:a 1 :b 2]

(let [respond {100 "Continue", 200 "OK"}] (respond 100))

"Continue"

(let [g (gensym)] (= g (symbol (name g))))

true

(let [number 1 number2 (* number 2)] number2)

2

(let [foo (fn [^Flibber e] 5)] (foo "tomas"))

5

((fn [x] (let [x (inc x)] x)) 1)

2

(let [x 1]
  (in-ns 'an-ns)
  (def y x))

#'user/y

(let [x 1] [`{:foo ~x} {:foo x}])

[{:foo 1} {:foo 1}]

(let [a (atom 1)] (swap! a (constantly 2)))

2

(let [{a :a} {:a "a", :b "b"}] a)

"a"

(let [[a b] (seq #{1 2})] a)

1

(let [do 10 if 40] (if do 5))

5

(let [[[k v]] (seq {:key 'val})] [k v])

[:key val]

(let [m {:a 1} {a :a} m] a)

1

(let [form '(/ 16 8)] `(~@form))

(/ 16 8)

(let [foo (fn this [] this)] (= foo (foo)))

true

(defmacro while-x-is-42 [expr] `(let [~'x 42] ~expr))

#'user/while-x-is-42

(let [x (range)] [(nth x 1e6) (first x)])

[1000000 0]

(macroexpand '(let [& 3] (+ & 1)))

(let [& 3] (+ & 1))

(let [part-command [:command :message]]
  (zipmap ["part" "leaving"] part-command))

{"leaving" :message, "part" :command}

(let [f (fn [] 3)] (list 1 2 (f)))

(1 2 3)

(doall (let [xs (map println (range 10))] xs))

(nil nil nil nil nil nil nil nil nil nil)

"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"

(let [a (atom 0)] (swap! a + 5))

5

(let [{:keys [a b]} {:a 1}] (println a))

nil

"1\n"

(let [args '("foo" "bar")] `(blah ~args))

(user/blah ("foo" "bar"))

(let [x (transient {:foo 42})] (contains? x :foo))

true

(let [[x y :as point] [1 2]] point)

[1 2]

(let [v (with-meta 'surname {:tag :key})] (meta v))

{:tag :key}

(let [x (doall (map println (range 10)))] 1)

1

"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"

(let [m 4 n ^{:abc String} m])

nil

(let [recipient "Rich"] (str "Dear " recipient ",\n"))

"Dear Rich,\n"