(let [foo 1 foo (+ foo 1)] foo)

2

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

{:b 1}

(let [a ()]
  (if-let [x (seq a)]
    :true-case
    :false-case))

:false-case

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

[[:a 1] nil]

(let [f #(- % 1)] (f 10))

9

(let [one 1 two 2] (str one two))

"12"

(let [s 'map] (macroexpand `(meta (var ~s))))

(clojure.core/meta (var map))

(let [string nil] (if string (.toLowerCase string) nil))

nil

(let [+* + + println] (+ 1 2))

nil

"1 2\n"

(let [x (range) y (seq x)] (realized? x))

true

(let [{{file-path :*} :route-params} {:route-params {:* "/mystery"}}] file-path)

"/mystery"

(let [x (fn f [] f)] (identical? (x) (x)))

true

(let [x 5] (#(< % x) 7))

false

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

(5 1 2 3)

(let [a 5] (list '* 1 2 a))

(* 1 2 5)

(let [a [Double/NaN]] (= (first a) (first a)))

true

(let [n 1] (and true (= n 1)))

true

(let [yo-momma 3 my-fatha 4] (+ yo-momma my-fatha))

7

(let [a 4 def 5] (+ a def))

9

(let [r (repeat 3)] (= r (next r)))

true

(let [x (empty? (map prn (range 2000)))] "foo")

"foo"

"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n"

(let [a #() b #()] (= a b))

false

(let [examplemap {:score 0}] (assoc examplemap :score inc))

{:score #object [clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"]}

(let [def 12] (+ 5 def 83 3))

103

(let [a '6 b '12] (+ a b))

18

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

(1 2 3 4)

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

[1 2]

(#(let [& 1 % 2] %1) 3)

2

(let [thing nil] (and thing (+ thing 42)))

nil

(let [a (delay (println :foo) 1)] [@a @a])

[1 1]

":foo\n"

(let [x {} y (with-meta x {})] (identical? x y))

false

(let [probs [1/4 1/2 1/4]] (reductions + probs))

(1/4 3/4 1N)

(let [v [:foo :bar]] (defn foo [x] v))

#'user/foo

(let [y [{:a "a", :b "b"}]] (into [] [y]))

[[{:a "a", :b "b"}]]

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

2

(let [xs (range 5)] (reduce conj xs xs))

(4 3 2 1 0 0 1 2 3 4)

(let [[m i] nil] {:m m, :i i})

{:i nil, :m nil}

(let [a ()] [(class (conj a 1)) (class a)])

[clojure.lang.PersistentList clojure.lang.PersistentList$EmptyList]

(let [f (nth (iterate constantly 42) 10)] ((((((((((f)))))))))))

42

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

(1 2 3 1)

(let [x 5 x (+ 5 x)] x)

10

(let [x 3] (read-string "`{:a ~x}"))

(clojure.core/apply clojure.core/array-map
  (clojure.core/sequence (clojure.core/seq (clojure.core/concat
                                             (clojure.core/list :a)
                                             (clojure.core/list x)))))

(let [tasks (atom [])] (swap! tasks into [(inc 1)]))

[2]

(let [i (quote (3 2 1))] (print i))

nil

"(3 2 1)"

(defmacro foo [form] `(let [~'x 42] ~form))

#'user/foo

(let [f ^{:awesome true} (fn [])] (meta f))

{:awesome true}

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

nil

"1 2\n"

(def baz (let [ns *ns*] (fn baz [] ns)))

#'user/baz

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

4

(let [ret (transient [])]
  (clojure.walk/prewalk (fn [x] (conj! ret x) x) '(let [x 123] (+ x 456)))
  (persistent! ret))

[(let [x 123] (+ x 456)) let [x 123] x 123 (+ x 456) + x 456]