(let [foo (with-out-str (println "9000"))] foo)

"9000\n"

(let [foo# 5] `(test ~foo#))

(clojure.core/test 5)

(let [d (delay (println "foo"))] 5)

5

(let [x (symbol "abc")] `(~x))

(abc)

(let [a Double/NaN] (identical? a a))

true

(let [a (def x 1)] 1)

1

(let [{:keys [:foo]} {:foo "bar"}] foo)

"bar"

(do `(let [x# 1] x#))

(clojure.core/let [x__3434290__auto__ 1] x__3434290__auto__)

(let [coll [1]] [coll (seq coll)])

[[1] (1)]

(let [s 'bla] `(ns ~s))

(clojure.core/ns bla)

(let [x_cool 1] (+ 1 x_cool))

2

(let [  2 a  ] a)

2

(let [a 1] (+ a 1))

2

(let [x 'foo] `(x ~x))

(user/x foo)

(let [x (float 6)] (type x))

java.lang.Float

(let [a 1 b a] b)

1

(let [x (atom 1)] (macroexpand '@x))

(clojure.core/deref x)

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

3

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

3

(let [{t :time} {:time "foo"}] t)

"foo"

(let [head first] (head [1 2]))

1

(let [{:keys [name]} (meta #'+)] name)

+

(let [x 1] `(clojure.core/unquote x))

1

(let [a 2 s 'a] s)

a

(let [x 1.7e90] ({x 12} x))

12

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

:bar

(let [new (constantly 1)] (new String))

""

(let [def 12] (+ 5 def))

17

(let [x '.toUpperCase] (println (x "a")))

nil

"nil\n"

(let [foo 1] (defn get-foo [] foo))

#'user/get-foo

(let [plus +] (plus 1 1))

2

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

nil

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

1

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

1

"1\n"

(let [n 1] (def foo n))

#'user/foo

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

:x

(let [[elem] '(1 2)] elem)

1

(let [regex #"foo[-][_]"])

nil

(let [foo +] (foo 2 3))

5

(let [[tween [_]] [15 [:tween]]] tween)

15

(let [x 3] `{:a ~x})

{:a 3}

(let [#^"[Ljava.lang.String;" arr (into-array ["foo"])])

nil

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

8

(let [map {}] (map :whatever [{:whatever :huh?}]))

[{:whatever :huh?}]

(let [return-value (constantly 17)] (fn? return-value))

true

(let [x 1 y 2] x)

1

(let [m {"1" 2}] (m "1"))

2

(defmacro returning
  [binding & body]
  (let [[sym expr] binding]
    `(let [~sym ~expr]
       ~@body
       ~sym)))

#'user/returning

(let [x (range) y (seq x)])

nil

(let [{t 'time} {'time "foo"}] t)

"foo"