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

"matches"

(let [a 0 b (inc a) a 2] b)

1

(let [a 1] (map class [a 'a :a "a"]))

(java.lang.Long clojure.lang.Symbol clojure.lang.Keyword java.lang.String)

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

[4]

(let [v []] (into v (for [i (range 3)] i)))

[0 1 2]

(let [q (fn [& a] (coll? a))] (q "foo"))

true

(let [x (list (list))] (every? #{(first x)} x))

true

(let [f (fn [x] (+ x 1))] (f 2))

3

(let [{a :a, :as m} 5] (println a m))

nil

"nil 5\n"

(let [the-map {"abc" (atom 1)}] (swap! (the-map "abc") inc))

2

(let [o *out*] (defn debug [s] (println o s)))

#'user/debug

(let [f (fn [x] (+ x 1))] (f 1))

2

(pr-str (let [x 10 y (inc x)] (fn [] y)))

"#object[sci.impl.fns$fun$arity_0__26683 0xac0127d \"sci.impl.fns$fun$arity_0__26683@ac0127d\"]"

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

[[1 2] [3 4]]

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

#'user/foo

(let [{:keys [a/b b]} {:a/b 12, :b 13}] b)

13

(let [fred (atom {:name "fred", :address "sycamore street"})] @fred)

{:address "sycamore street", :name "fred"}

(let [c 17] (quote (a b (unquote c) d)))

(a b (unquote c) d)

(defmacro foo [] (let [x (ns-name *ns*)] `(print ~x)))

#'user/foo

(let [vector? (memoize vector?)] [(vector? [1]) (vector? '(1))])

[true true]

(let [a (range 1 12)] (format "%s" (str a)))

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

(let [ms #{{:a 10}}] (get-in ms [{:a 10}]))

{:a 10}

(let [my-name "Konstantinos"] (println (str "hello " my-name "!")))

nil

"hello Konstantinos!\n"

(let [a [0] b (conj a 1)] [a b])

[[0] [0 1]]

(macroexpand '(let [if 3] (and x y z)))

(let [if 3] (and x y z))

(let [[f & r] [1 2 3]] [f r])

[1 (2 3)]

(let [[a b & c] (range 3 9)] a)

3

(let [a (transient {})] (= a (assoc! a :b :c)))

true

(let [my-vector [1 2 3 4 5]] (my-vector 2))

3

(let [do not don't (not do)] (do (or) don't))

false

(let [bullshit (fn [x] (+ -1 x))] (bullshit 33))

32

(let [x 'y y 1] `(~(resolve x)))

(nil)

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

18

(let [args '(1 2 3 4)] (pop args))

(2 3 4)

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

#'user/foo

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

[2 1]

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

[user/x 1 2 3]

(let [gs #{{:a 10}}] (get-in gs [{:a 10}]))

{:a 10}

(let [m (re-matcher #"x\d" "x1x2x3")] [(re-find m) (re-find m)])

["x1" "x2"]

(let [s (range 10)] (into {} (map vector s s)))

{0 0, 1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7, 8 8, 9 9}

(let [f inc x 1] `(~(f x)))

(2)

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

5

(let [{:keys [name age]} {:name "Joe", :age 30}] name)

"Joe"

(defn my-fn [x] (let [y 10] (+ x y)))

#'user/my-fn

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

true

(defn foo [] (let [foo (fn [] 2)] (+ (foo) 3)))

#'user/foo

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

2

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

"li1ei40e4:sean"

(let [vect [1 2 3 4 5]] (rest vect))

(2 3 4 5)

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

(1 2 1 2)