(let [a (atom 5)]
  (swap! a inc)
  @a)

6

(let [variable [:a :b :c]] (nth variable 2))

:c

(let [x 2] (apply * [1 x 3]))

6

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

999999

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

"nothing"

(let [my-name "Konstantinos"] (println (format "hello %s" my-name)))

nil

"hello Konstantinos\n"

(let [example "hello" example (take 3 example)] example)

(\h \e \l)

(let [[:as [:as [:as [:as n]]]] 6] n)

6

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

4

(let [[_ & r] '(1)] (nil? r))

true

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

true

(let [x 1] (if (coll? x) x [x]))

[1]

(let [my-reverse rseq] (my-reverse [1 2 3 4]))

(4 3 2 1)

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

1

(defmacro foo [bar] '(let [x ~bar] ...))

#'user/foo

(take-while number?
            (let [mutable (atom 0)]
              (repeatedly #(let [r @mutable]
                             (when (< r 5) (swap! mutable inc) r)))))

(0 1 2 3 4)

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

7

(let [x [:tr (if true [:th "Vote"])]] x)

[:tr [:th "Vote"]]

(let [{hit-points :hp} {:hp 100, :mana 10}] hit-points)

100

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

10

(let [^double x (identity Double/NaN)] (= x x))

true

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

0

(defmacro where [expr lettings] `(let ~lettings ~expr))

#'user/where

(let [v ^{:tag :key} ['surname]] (meta v))

{:tag :key}

(let [test [:a :b :c]] (nth test 2))

:c

(let [A true B false] (and A B))

false

(let [a (atom 0)]
  (swap! a inc)
  @a)

1

(let [do 12 if 19] (+ do if))

31

(let [c 63] (bit-shift-right (bit-shift-left 1 c) c))

-1

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

nil

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

3

(let [x 10 y 12] (list [x] [y]))

([10] [12])

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

[user/foo 1 2 3]

(let [x (transient [])]
  (conj! x x)
  (persistent! x))

[#object
  [clojure.lang.PersistentVector$TransientVector 0x44f7a050
   "clojure.lang.PersistentVector$TransientVector@44f7a050"]]

(let [x (first (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 {}] (identical? a (with-meta a {:foo 1})))

false

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

(4)

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

20

(let [[_ {foo :key}] [:keyword {:key "value"}]] foo)

"value"

(macroexpand '(let [{:keys [fn interval]} m] ...))

(let [{:keys [fn interval]} m] ...)

(let [x false] (or (true? x) (false? x)))

true

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

[1 2]

(let [blah 42] (with-local-vars [blah :nambla] (var-get blah)))

:nambla

(let [list '[a-list of elements]] (println list))

nil

"[a-list of elements]\n"

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

[2 1]

(let [is-foo? #(= % "foo")] (is-foo? "foo"))

true

(let [[lat lon] ((fn [] [1 2]))] [lat lon])

[1 2]

(let [[_ a b] (range)] (+ a b))

3

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

[:a]

(defn testfn [] (let [x 1] (+ x 2)))

#'user/testfn