(let [a "5" b 10] (Integer/valueOf ^Integer a b))

5

(let [☃ "hey would you look at that"] ☃)

"hey would you look at that"

(defn foo [x] (let [y 3] (+ x y)))

#'user/foo

(binding [*print-meta* true] (let [foo ^:foo 'x] (pr-str foo)))

"x"

(let [a (atom 0)] (defn inc-counter [] (swap! a inc)))

#'user/inc-counter

(let [s "li1ei40e4:seane"] (.substring s 0 (dec (.length s))))

"li1ei40e4:sean"

(defn func [param] (let [param (- param 1)] param))

#'user/func

(let [some-list [1 2 3 4]] (apply + some-list))

10

(let [x (gensym)] `[(inc ~x) `(inc ~~x)])

[(clojure.core/inc G__3087823)
 (clojure.core/sequence
   (clojure.core/seq (clojure.core/concat (clojure.core/list
                                            (quote clojure.core/inc))
                                          (clojure.core/list G__3087823))))]

(let [... :silence] (apply str (repeat 2 (name ...))))

"silencesilence"

(let [myseq (take 30 (repeatedly #(rand-int 30)))] myseq)

(0 17 2 25 21 18 14 19 11 11 8 14 3 3 4 14 22 29 10 3 11 24 27 19 16 5 6 9 8 19)

(let [foo (gensym)] [`(bar ~foo) `(zonk ~foo)])

[(user/bar G__3441226) (user/zonk G__3441226)]

(let [x {:foo [1 2 3]}] (println (:foo x)))

nil

"[1 2 3]\n"

(let [[a b :as c] nil] [a b c])

[nil nil nil]

(let [[f & vs] '(/ 16 8)] `~f)

/

(let [ctr (atom 0)] (defn counter [] (swap! counter inc)))

#'user/counter

(let [a {:a 0}]
  (assoc a :b 1)
  a)

{:a 0}

(let [v [1 2 3]] [v (map identity v)])

[[1 2 3] (1 2 3)]

(let []
  (map println #{1 2})
  (map println #{}))

()

(let [x (resolve 'a)] (def f (fn [] (inc @x))))

#'user/f

(let [x 2] (cond-> x (even? x) (+ 1)))

3

(let [f (fn [x] (* x x))] (f 2))

4

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

3

(let [set-thing #{1 2 3}] (conj set-thing 5))

#{1 2 3 5}

(let [keyvals '(1)] (assoc {} (first keyvals) (second keyvals)))

{1 nil}

(let [l (list 1 2 3)] `(foo ~@l))

(user/foo 1 2 3)

(let [v (def a)] [(meta v) (identical? v #'a)])

[{:file nil,
  :name a,
  :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"]} true]

(let [x (range 10)] (map str [x (list* x)]))

("(0 1 2 3 4 5 6 7 8 9)" "(0 1 2 3 4 5 6 7 8 9)")

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

3

(let [{x :k, :or {x 1}} {:k nil}] x)

nil

(let [[a & rest] [1 2 3 4]] a)

1

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

false

(let [x '[a b c]] `(example ~@x))

(user/example a b c)

(let [x (byte-array 5)] (and (class? x) (.isArray x)))

false

(let [n 5 square (* n n)] (print square))

nil

"25"

(let [s "foo"] (condp = s "foo" "Win" "Lose"))

"Win"

(macroexpand-1 '(let [[h & t] [1]] [h t]))

(let [[h & t] [1]] [h t])

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

(0 1 2 3)

(let [f (with-meta + (meta +))] [f (meta f)])

[#object [clojure.core$_PLUS_ 0x35b52c2b "clojure.core$_PLUS_@35b52c2b"] nil]

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

(nil nil)

(let [foo "bar"] (defn baz [bat] (str bat foo)))

#'user/baz

(defmacro with-foo [& body] `(let [foo "foo"] ~@body))

#'user/with-foo

(let [a (delay (println "test") 1)]
  (println "test2")
  @a)

1

"test2\ntest\n"

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

[1 (2 3)]

(let [val 42] (apply hash-map [[:key val] [:key val]]))

{[:key 42] [:key 42]}

(let [[a b c] (clojure.string/split "d,a,b,c" #",")] [a b])

["d" "a"]

(let [a #()] (= a (with-meta a {:a 1})))

false

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

[1 2]

(let [∞ Double/POSITIVE_INFINITY] (take 5 (range 6 ∞ 6)))

(6 12 18 24 30)

(let [x {:a :b} y (doto x println)] y)

{:a :b}

"{:a :b}\n"