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

2

(let [var 'foo] `(list ~var))

(clojure.core/list foo)

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

[1 2 3]

(let [h {"hello" "world"}] (class h))

clojure.lang.PersistentArrayMap

(let [{x 3} {3 :foo}] x)

:foo

(let [#^Keyword x :y] (type x))

clojure.lang.Keyword

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

nil

(let [#^String x "a"] (prn x))

nil

"\"a\"\n"

(let [arg 'wooo-symbol] `(println ~arg))

(clojure.core/println wooo-symbol)

(let [{:keys [whatever/a]} {:whatever/a 0}] a)

0

(let [foo# 100] (+ foo# 999))

1099

(let [v 'test] `(foo #'~v))

(user/foo (var test))

(let [v '[foo 123]] v)

[foo 123]

(let [z# 10] `(~z# z#))

(10 z__3077644__auto__)

(let [^int x 5] (class x))

java.lang.Long

(let [| (constantly '(|))] (|))

(|)

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

123

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

1

(let [x 1] '[(x :seq)])

[(x :seq)]

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

5

(let [| 5] (* | 2))

10

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

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

(let [k :keyword] (k {:k 10}))

nil

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

"bar"

(let [x 1] `(unquote x))

(clojure.core/unquote user/x)

(let [out 'foo] ({#'*out* out} #'*out*))

foo

(let [c "c"] (str c "=me"))

"c=me"

(let [t (range)] (take 20 t))

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

(let [foo (+ 1 1)] foo)

2

(let [+ -] (+ 10 2))

8

(let [map {:menuName "hello2"}] (map :menuName))

"hello2"

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

[1 1 2]

(let [curr-ns *ns*] (defn that-ns [] curr-ns))

#'user/that-ns

(let [f `foo#] (= f f))

true

(let [f #(prn "hey")] (f))

nil

"\"hey\"\n"

(let [foo 'bar] `(keyword ~foo))

(clojure.core/keyword bar)

(let [x 1 y x] y)

1

(let [a '(1)] (cons a ()))

((1))

(let [[x & args] [1]] args)

nil

(let [ns *ns*] (defn x [] ns))

#'user/x

(let [^{a b} foo []] foo)

[]

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

1

(let [{:keys [a/b]} {:a/b 12}] b)

12

(let [{:keys [:foo]} {:foo 42}] foo)

42

(let [[tree & trees] (range)] tree)

0

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

nil

"nil\n"

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

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

(try (let [a (keys [1])] :ok))

:ok

(meta (let [x "hi"] #^:a x))

nil

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

nil