(let [x (promise)] (x 2) @x)
2
(let [e nil] (def comment nil))
#'user/comment
(let [shadow 1] (+ shadow 1))
2
(let [foo (fn [] 1)] (class foo))
sci.impl.fns$fun$arity_0__26683
(let [x =] (x = x))
true
(let [foo '=] (meta (resolve foo)))
{:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name =, :sci/built-in true, :arglists ([x] [x y] [x y & more]), :doc "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, ...
(let [foo (fn [] ())] (macroexpand-1 `('foo)))
((quote user/foo))
(let [a 'b] (def a 9))
#'user/a
(let [coords (let [xs [-1 0 1]] (for [x xs y xs] [x y]))] coords)
([-1 -1] [-1 0] [-1 1] [0 -1] [0 0] [0 1] [1 -1] [1 0] [1 1])
(let [[aa bb] (let [{:keys [a b]} {:a 1, :b 2}] [a b])] [aa bb])
[1 2]
(defmacro if-some [bindings then else] (let [form (bindings 0) tst (bindings 1)] `(let [temp# ~tst] (if (nil? temp#) ~else (let [~form temp#] ~then)))))
#'user/if-some
(macroexpand-1 (let [p true] `(let [x# 7 y# 8] ~(if p `x# `y#))))
(clojure.core/let [x__1238473__auto__ 7 y__1238474__auto__ 8] x__1238471__auto__)
(let [a {:b [:c :d]}] (let [[x [y z]] (first (seq a))] (println x y z)))
nil
":b :c :d\n"
(let [hello #(println %)] (hello "world"))
nil
"world\n"
(let [a 1] (do (println a) a))
1
"1\n"
(let [x 10 y 12] [x y])
[10 12]
(let [x '()] (identical? x (seq x)))
false
(let [x 1 y 2] [x y])
[1 2]
(macroexpand-1 (macroexpand-1 '(let [x 1] x)))
(let [x 1] x)
(let [b 1] (eval (list (fn [] b))))
1
(macroexpand-1 '(let [[a b] (range)] b))
(let [[a b] (range)] b)
(let [x "\ufeffPersonnelNbr"] (= (.trim x) x))
true
(let [f rest] (f [1 2 3]))
(2 3)
(let [{a :a} (seq [:a :A])] a)
:A
(let [[x & xs] '(1)] xs)
nil
(let [l 50] [(class l) (Integer. l)])
[java.lang.Long 50]
(let [xs [[1] [2]]] `[:div ~@xs])
[:div [1] [2]]
(let [group (partial partition-by identity)] (group "aabbbc"))
((\a \a) (\b \b \b) (\c))
(let [x 1 y 2] (prn x))
nil
"1\n"
(let [a (Double/valueOf Double/NaN)] (identical? a a))
true
(let [a 1 b (inc a)] b)
2
(let [x :let] (def x :def) x)
:let
(let [q '((a b) ())] (second q))
()
(let [x (atom 12343)] (identical? x x))
true
(let [{x :x} (list :x 1)] x)
1
(let [x (map println (range 10))] 1)
1
(let [{:keys [test]} '(:test 1)] test)
1
(let [ys (range 10)] (filter even? ys))
(0 2 4 6 8)
(macroexpand '(let [[x :as all] (range)]))
(let [[x :as all] (range)])
(let [] (print 'a) (print 'b) (print 'c))
nil
"abc"
(let [myfn (fn [& [arg]] arg)] (myfn))
nil
(let ((x 1)) `(1 x 2))
(1 user/x 2)
(let [{a :a, :or {a 5}} {}] a)
5
(let [{x :x, :or {x 2}} {}] x)
2
(let [v '^:key surname] (meta v))
{:key true}
(let [foo "hello" bar "world"] `(~'foo/bar))
(foo/bar)
(let [{:keys [time]} {:time "foo"}] [time time])
["foo" "foo"]
(let [blah 1] ['(blah) (list blah)])
[(blah) (1)]
(let [a 2 s 'a] (resolve s))
nil
(let [c []] (if (seq c) "something" "nothing"))
"nothing"