(let [a :foo] (case a :foo (println "YES")))

nil

"YES\n"

(let [f "hello"] `(f ~f 'f ~'f))

(user/f "hello" (quote user/f) f)

(let [x "yay" y (println (str "yo"))] x)

"yay"

"yo\n"

(let [value true] (and value (assoc {} :test value)))

{:test true}

(let [e 'for] (prn (macroexpand-1 '(doc e))))

nil

"^{:line 1, :column 36} (doc e)\n"

(defmacro where [expr lettings] `(let ~lettings expr))

#'user/where

(let [{:as x} nil {:as y} []] [x y])

[nil []]

(+ 10 (let [x 2] (* x x)))

14

(let [a 1 b 2] (+ a b))

3

(let [xs [1 2 3]] `(+ ~@xs))

(clojure.core/+ 1 2 3)

(let [[x & xs] [1 2 3 42]])

nil

(let [_ (defmacro m4 [] 2)] (m4 nil nil))

2

(meta (let [i 1] #^{:foo i} [i]))

{:foo 1}

(let [a (atom 5)] (take @a (range 9)))

(0 1 2 3 4)

(let [x (atom 5)] `(do ~@x))

(do 5)

(let [x 1] (eval `(+ ~x 1)))

2

(let [a (atom 0)]
  (reset! a "foo")
  @a)

"foo"

(let [v [1 2 3]]
  mapv
  println
  v)

[1 2 3]

(let [foo + bar 10] (foo 2 bar))

12

(let [[a b] (re-find #"abc" "abc")] [a b])

[\a \b]

(let [s "\uD834\uDD1E"] (.codePointCount s 0 (.length s)))

1

(let [s "/\\\""] (= (name (symbol s)) s))

false

(let [x 1] (replicate 4 (replicate 4 x)))

((1 1 1 1) (1 1 1 1) (1 1 1 1) (1 1 1 1))

(let [x (atom 0)]
  (swap! x inc)
  @x)

1

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

3

(let [x 1] `(foo bar x ~x))

(user/foo user/bar user/x 1)

(let [{a :a} {:a 1, :b 2}] a)

1

(let [foo #(+ % 1)] (foo 100))

101

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

[2 1 0]

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

(a b)

(let [{v :k} 'm1] ["My v is" v])

["My v is" nil]

(let [[a b] (map int "xy")] [a b])

[120 121]

(let [id1 {:id 1}] (= id1 {:id 1}))

true

(defn take-from-q [q] (let [q-interaction (.take q)] q-interaction))

#'user/take-from-q

(let [x "Dave"] (str "Hello, " x "!"))

"Hello, Dave!"

(let [coll '(1 3 2 4 6)])

nil

(let [blah 42] (with-local-vars [blah blah] (var-get blah)))

#'G__3402251

(let [foo (transient [])]
  (conj! foo 1)
  (persistent! foo))

[1]

(macroexpand '(let [[s & r] 10] s))

(let [[s & r] 10] s)

(let [a 10] ['{:val a} {:val a}])

[{:val a} {:val 10}]

(let [xs (range 3)] [(str xs) (pr-str xs)])

["(0 1 2)" "(0 1 2)"]

(let [a (atom true)]
  (reset! a false)
  @a)

false

(macroexpand (let [method 'foo] `(. bar ~method)))

(. user/bar foo)

(let [tf (list 3 4)] `(1 ~@tf))

(1 3 4)

(let [foo 42 bar 23] (list foo bar))

(42 23)

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

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

(let [[[k v]] (seq {3 4})] [k v])

[3 4]

(let [+ + + + + +] (+))

0

(let [f 'foo] (= f (read-string (pr-str f))))

true

(let [[name hp] ["Sgeo" 100 :foo]] [hp name])

[100 "Sgeo"]