(let [myfn (fn [& [arg]] arg)] (myfn))

nil

(let ((x 1)) `(1 x 2))

(1 user/x 2)

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

5

(let [{x :x, :or {x 2}} {}] x)

2

(let [{a 'a} {'a 'a}] (type a))

clojure.lang.Symbol

(let [{:keys [time]} {:time "foo"}] [time time])

["foo" "foo"]

(let [blah 1] ['(blah) (list blah)])

[(blah) (1)]

(let [{:strs [a]} {"a" 41}] (inc a))

42

(let [id 567] (str "^" id "\\s"))

"^567\\s"

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

{:key true}

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

(clojure.core/+ 1 2)

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

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

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

[2 1]

(let [x "\ufeffPersonnelNbr"] (= (.trim x) x))

true

(let [foo 5] [`foo `(foo ~foo)])

[user/foo (user/foo 5)]

(let [a 0
      b 1]
  a
  b)

1

(let [[a & b] nil] [a b])

[nil nil]

(let [m {:k :v}] (:k m identity))

:v

(let [x 1 x (inc x)] x)

2

(let [[a] (range)] [a a a a])

[0 0 0 0]

(let [x (sorted-map-by compare)] (compare x x))

0

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

[(1 2) [2 1]]

(defn foo [] (let [foo inc] (foo 1)))

#'user/foo

(let [foo ['foo 1]] (with-redefs ~foo foo))

[foo 1]

(let [hello :moo] `(+ 1 ~hello))

(clojure.core/+ 1 :moo)

(let [if 3] (and 1 2 5))

5

(let [a (atom {})]
  (-> 1
      (@a)
      :ugh))

nil

(let [f (partial apply list)] (f nil))

()

(let [fs (juxt inc dec)] (fs 1))

[2 0]

(let [data :foo] {:a data, :b data})

{:a :foo, :b :foo}

(let [mymac (fn [arg] `(let [~'x 4] (* ~arg ~'x))) x 10] (mymac x))

(clojure.core/let [x 4] (clojure.core/* 10 x))

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

"something"

(let [if 5] (if if :true :false))

:true

(let [x (atom 0)] (swap! x dec'))

-1

(let [[x & xs] (range 5)] xs)

(1 2 3 4)

(let [a 'foo] `(* 2 ~a))

(clojure.core/* 2 foo)

(let [lol (fn [] (fn []))] (= (lol) (lol)))

false

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

true

(let [a 5] (defn ^:static foo [] a))

#'user/foo

(let [g (gensym)] [g (= g 'G__85847)])

[G__59158 false]

(let [foo "1.2.3"] (into [] (.split foo ".")))

[]

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

[:a]

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

(let [[a & r] s])

(let [x nil] ^{:tag Collection} x)

nil

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

2

(let [c "c"] (re-pattern "ab(c)"))

#"ab(c)"

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

1

(let [identity (comp clojure.repl/demunge munge)] (identity "_"))

"-"

(let [x 4
      (comment
        y
        5)]
  x)

4

(defmacro afunc [input] `(let [escape ~input]))

#'user/afunc