(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 [a 1 b (inc a)] b)

2

(let [x :let]
  (def x :def)
  x)

:let

(let [not...or identity DIE 42] (not...or DIE))

42

(let [my-name "Konstantinos"] (println "hello" 'my-name \!))

nil

"hello my-name !\n"

(let [{n 0, :or {n :a}} [:a]] [])

[]

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

2

(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 [f rest] (f [1 2 3]))

(2 3)

(let [{a :a} (seq [:a :A])] a)

:A

(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 & 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 [{:keys [test]} '(:test 1)] test)

1

(let [q '((a b) ())] (second q))

()

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

true

(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 [a {}]
  (assoc a :b 1)
  a)

{}

(let [a 2 s 'a] (resolve s))

nil

(println (second '(let [x 42] x)))

nil

"[x 42]\n"

(macroexpand '(let [[x :as all] (range)]))

(let [[x :as all] (range)])

(let []
  (print 'a)
  (print 'b)
  (print 'c))

nil

"abc"

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

{:key true}

(let [foo "hello" bar "world"] `(~'foo/bar))

(foo/bar)

(let [ys (range 10)] (filter even? ys))

(0 2 4 6 8)

(let [c []] (if (seq c) "something" "nothing"))

"nothing"

(let [sym '+] `(= ~sym '~sym))

(clojure.core/= + (quote +))