(macroexpand '(let [if 3] (+ 1 2 3)))

(let [if 3] (+ 1 2 3))

(defmacro foo [& body] `(let [~'a 1] ~@body))

#'user/foo

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

6

(let [x {:key "I Worship His Shadow"}] (x :key))

"I Worship His Shadow"

(let [add (fn [x] (+ 1 x))] (add 6))

7

(let [ab-adder (partial concat [:a :b])] (ab-adder [:c :d]))

(:a :b :c :d)

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

[1 2 nil]

(let [x (print "nn all ")] (repeat 5 x))

(nil nil nil nil nil)

"nn all "

(let [[x & y :as z] []] [x y z])

[nil nil []]

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

nil

"\"1 2\""

(let [[:as p] '(1 2 3 4)] p)

(1 2 3 4)

(let [x #{}] (if (seq x) [] (conj x 10)))

#{10}

(str (let [f "foo"]
       (reify
         Object
           (toString [this] f))))

"foo"

(let [sth {:keyword (atom true)}] (prn @(:keyword sth)))

nil

"true\n"

(let [a (double-array '(1.2 2.3))] (aget a 1))

2.3

(let [[function & args] (list '/ 1 3)] function)

/

(macroexpand-1 '(let [seq (range 10)] `(do ~@seq)))

(let [seq (range 10)]
  (clojure.core/sequence (clojure.core/seq (clojure.core/concat
                                             (clojure.core/list (quote do))
                                             seq))))

(let [xs (map println (range 10))]
  (doall xs)
  1)

1

"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"

(let [tf (juxt + - *)] (tf 1 2))

[3 -1 2]

(let [{i :foo} {:foo {:bar 1, :baz 2}}] [i])

[{:bar 1, :baz 2}]

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

[1 2]

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

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

(defmacro good-duplicate [expr] `(let [x# ~expr] [x# x#]))

#'user/good-duplicate

(let [a "s"]
  (case (class a)
    java.lang.String :found
    :not-found))

:not-found

(let [v [1 2]] (identical? (rest v) (rest v)))

false

(let [x (+ 1 (if true 2 1000))] x)

3

((fn [x] (let [[a b] x] b)) [1 2])

2

(let [x 3] ((fn [y] (+ x y)) 4))

7

(let [s "text.xml"] (.substring s 0 (.lastIndexOf s ".")))

"text"

(let [x {}] (= x (vary-meta x assoc :a 'bc)))

true

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

2

(let [x '(1 2 3)] `[~x ~@x])

[(1 2 3) 1 2 3]

(let [coll (range 5)] (zipmap coll (map str coll)))

{0 "0", 1 "1", 2 "2", 3 "3", 4 "4"}

(->> 3
     (- a)
     (/ 4)
     (let [a 7]))

1

(let [our-addition #(+ % %2)] (our-addition 3 5))

8

(let [x [1 2 3]] `(foo ~@x bar))

(user/foo 1 2 3 user/bar)

(let [[function & args] (list '/ 1 3)] args)

(1 3)

(let [sexpbot-trigger "##(+ 7 8)"] (first sexpbot-trigger))

\#

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

[1 2]

(defmacro alter-my-args [& body] `(let [~'% 10] ~@body))

#'user/alter-my-args

(let [a (promise)]
  (deliver a 10)
  (deliver a 20))

nil

(let [if 10 do 20] (if do (do if)))

10

(defmacro foo [& body] `(let [~'x 3] ~@body))

#'user/foo

(let [c (short 1)] (case c (short 1) "matches"))

"matches"

(let [a (atom '(1))] (swap! a conj 0))

(0 1)

(let [^{:foo :bar} x 1] (meta (var x)))

nil

(let [p+ (apply partial + (range 1000000.0))] (p+ 10))

499999500010

(let [m {:hello 1, :world 2}] (map :hello [m]))

(1)

(let [b (for [i (range 5)] (print i))] nil)

nil

(let [x (range 1)] (reduce (comp flatten vector) x))

0