(macroexpand `(let [a 1] a))

(clojure.core/let [user/a 1] user/a)

(let [[a b] [1]] (println b))

nil

"nil\n"

(let [bla 'foo] (meta '^:foo ~bla))

{:column 24, :foo true, :line 1}

(let [a 4 a 5] a)

5

(let [{:x :x} {:x 1}] x)

1

(let [b 2] `(let [a 1] `(blah blah ~a blah ~~b blah)))

(clojure.core/let [user/a 1]
  (clojure.core/sequence
    (clojure.core/seq
      (clojure.core/concat (clojure.core/list (quote user/blah))
                           (clojure.core/list (quote user/blah))
                           (clojure.core/list user/a)
                           (clojure.core/list (quote user/blah))
                           (clojure.core/list 2)
                           (clojure.core/list (quote user/blah))))))

(let [x (symbol "x") y 'x] `(let [~x 1] (print (+ ~y 1))))

(clojure.core/let [x 1] (clojure.core/print (clojure.core/+ x 1)))

(let [m {'a 71, 'b :foo}]
  `(let [~@(apply concat m)]
     foo
     bar))

(clojure.core/let [a 71
                   b :foo]
  user/foo
  user/bar)

(let [a 1 b (inc a)] (let [[a b] [b (inc a)]] [a b]))

[2 2]

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

[1 2]

(let [m {:host "irc.freenode.net", :writer "whatever"}]
  (let [{:keys [host writer]} m] (println host writer)))

nil

"irc.freenode.net whatever\n"

(let [&env 42] (defmacro forty-two [] &env))

#'user/forty-two

(let [{a 'a} {'a 'a}] a)

a

(let [[pair] (seq {:foo :bar})] pair)

[:foo :bar]

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

3

(let [c (str "hi")] (.length c))

2

(let [v ^:key ['surname]] (meta v))

{:key true}

(let [^String y "abc"] (meta y))

nil

(let [-' [10]] (clojure.core/seq (clojure.core/concat -')))

(10)

(let [x 1 y 2] x)

1

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

1

(let [+ -] (+ 3 4))

-1

(let [x 42] (+ x x))

84

(let [x (fn [])] (= x x))

true

(let [x 666] (== x x))

true

(let [boat 1] (class (float boat)))

java.lang.Float

(let [s "asdf"] (re-find #"a" s))

"a"

(let [h {:foo "bar", :foo2 "bar"}])

nil

(let [nana Double/NaN] (== nana nana))

false

(let [+ *] (+ 3 3))

9

(let [foo (fn [] (resolve 'bar))] nil)

nil

(let [bbb 5] ({bbb 6} bbb))

6

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

4

(macroexpand '(let [[a] b] a))

(let [[a] b] a)

(let [foo. 5] (+ foo. 5))

10

(let [x 5] (+ #'x 6))

11

(let [x []]
  (conj x "1")
  x)

[]

(let [foo 42] `(keyword ~foo))

(clojure.core/keyword 42)

(let [[a b] nil] [a b])

[nil nil]

(let [#^String x "a"] (.length x))

1

(let [{:keys [x]} {:x 666}] x)

666

(macroexpand-1 '(fn [] (let [blah 1])))

(fn [] (let [blah 1]))

(let [+ -] (+ 5 3))

2

(let [foo# 10] `(inc ~foo#))

(clojure.core/inc 10)

(let [x 1]
  (println x)
  x)

1

"1\n"

(let [nan Double/NaN] (= nan nan))

true

(let [{:strs [foo]} {"foo" 123}] foo)

123

(let [a (gensym)] `(foo ~a))

(user/foo G__1231217)

(let [{:keys [foo/bar]} {:foo/bar 1}] bar)

1

(let [a 1 b a] b)

1