((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