(let [a 42 b 43] (or a b))

42

(let [{a 2, b 3} "foobar"] [a b])

[\o \b]

(let [f "foo" g "foo"] (= f g))

true

(let [x #(.toUpperCase %)] (println (x "a")))

nil

"A\n"

(let [[[k v]] (seq {:a 1})] [k v])

[:a 1]

(macroexpand-1 '(let [{a :a} {:a 5}] a))

(let [{a :a} {:a 5}] a)

(let [dbval 1] (list [:h1 dbval] [:h2 dbval]))

([:h1 1] [:h2 1])

(eval '(let [y 3] (+ y 1)))

4

(let [a + + 2] (a + 4))

6

(let [ŭ #(+ 2 %)] (ŭ 3))

5

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

2

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

(1 (3 4))

(let [x 5 f (constantly x)] (f 'sdafjksde))

5

(let [v -50] (max (min 0 v) 100))

100

(let [a 1 b (inc a)] [a b])

[1 2]

(let [? 2 ? 3] (+ ? ?))

6

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

[[3 4] nil]

(let [foo map]
  (-> foo
      var
      meta
      :arglists))

nil

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

[1 nil nil]

(defmacro m [] (let [a 1] `(list ~a)))

#'user/m

(let [foo (atom nil)]
  (reset! foo foo)
  nil)

nil

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

(clojure.core/+ 1 2 3)

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

2

(let [myfun (fn [a] (inc a))] (myfun 42))

43

(let [a [1 2]] `[3 ~@a 4])

[3 1 2 4]

(let [x (short 0)] ({0 "zero"} (int x)))

"zero"

(let [x 41] (def y (* x 2)))

#'user/y

(let [f "foo" b "bar"] (str f b))

"foobar"

(let [r (range 1e6)]
  (last r)
  (first r))

0

(defmacro blah [fieldname] `(let [example# 42] 42))

#'user/blah

(let [x 10 y 20] `[x y])

[user/x user/y]

(defmacro run [f] (let [s (rest f)] s))

#'user/run

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

1

(let [x 3]
  (if-let [x nil]
    x
    x))

3

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

20

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

1

(let [s (read-string "2")] (pr (+ 1 s)))

nil

"3"

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

123

(let [v (vec (repeat 9 nil))] [v v])

[[nil nil nil nil nil nil nil nil nil] [nil nil nil nil nil nil nil nil nil]]

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

2

(let [x# '(1 2 3)] (first x#))

1

(let [f (fn [x] (inc x))] (f 4))

5

(let [[a] [1 2 3 4 5]] a)

1

(let [[a :as x b] [1 2]] a)

1

(let [rg (set (range 50000))] (count (set rg)))

50000

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

[nil nil nil]

"1\n2\n3\n"

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

()

(let [{:keys [dir]} {:dir 1, :dor 2}] dir)

1

(let [*read-eval* false] (map read-string ["1" "2" "3"]))

(1 2 3)

(let [[x y z] [1 2 3]] y)

2