(let [x (symbol "clojure.contrib.math")] (in-ns x))

nil

(let [{t +} {+ :foo}] t)

:foo

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

1

(->> (inc a)
     (let [a 5]))

6

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

17

(let [s 'println] ((resolve s) "Hello..."))

nil

"Hello...\n"

(let [[a b c] (range)] c)

2

(let [i (gensym)] `(do ...))

(do user/...)

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

1

(do (let [a 3] (println `~a)))

nil

"3\n"

(let [x 130] (identical? x x))

true

(let [blah nil] (if blah (blah)))

nil

(let [x #{}] (conj x 'a))

#{a}

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

10

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

2

(let [foo ["1" "3"]] `(~@foo))

("1" "3")

(let [brehaut (rand-int 10)] (inc brehaut))

7

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

#'user/x

(let [a 3] #{a 3})

#{3}

(let [{foo :b.c} {:b.c 42}] foo)

42

(let [+ -] (+ 4 3))

1

(let [x 1] (print x 'x))

nil

"1 x"

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

1

(let [x [:test]] (contains? x 0))

true

(let [{:syms [foo]} {'foo 0}] foo)

0

(let [^Foo x 1] ^Foo x)

1

(let [x 1] (#(identity x)))

1

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

[1 1 2]

(let [x 20] (defn foo [] x))

#'user/foo

(let [Long String] (instance? Long "abc"))

true

(let [what "is going on"] what)

"is going on"

(let [crazy-hashmap {() [], #() {}}] (get crazy-hashmap ()))

[]

(let [key :keyword] (key {:keyword :yes}))

:yes

(let [[x y] [1]] [x y])

[1 nil]

(macroexpand-1 '(let [x 1] x))

(let [x 1] x)

(let [a 12] `[y ~a])

[user/y 12]

(let [[x & xs] [1 2 3 4 5]] xs)

(2 3 4 5)

(let [s (var println)] (s "hello"))

nil

"hello\n"

(let [sym (gensym (quote obj))] sym)

obj3077249

(let [a 10] (+ a a))

20

(let [gfred 1] (+ gfred gfred))

2

(let [victor ["roger" "Roger"]] (vector? victor))

true

(let [^String foo "foo"] (meta foo))

nil

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

((clojure.core/unquote user/x))

(let [x 1] [x (quote x)])

[1 x]

(let [v [:a :b]] (v 1))

:b

(let [a (Object.)] (identical? a a))

true

(let [{foo :name} {:name "SegFaultAX"}] foo)

"SegFaultAX"

(let [toString 'hashCode] (. "foo" toString))

"foo"

(= 1 (let [z 1] z))

true