(let [{a 0, b 1, :or {b 43}} [42]] [a b])

[42 43]

(let [[_ [_ [_ a]]] [1 [2 [3 [4 5]]]]] a)

[4 5]

(let [a 3] `(a ~a (inc a) ~(inc a)))

(user/a 3 (clojure.core/inc user/a) 4)

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

3

(let [[n l r & st] '(:a :b nil)] st)

nil

(let [x 8 y 3] ((comp + - -) x y))

-5

(let [myset (sorted-set-by <)] (into myset #{4 7 1 6}))

#{1 4 6 7}

(let [stuff [3 4 5]] `(1 2 ~@stuff 6 7))

(1 2 3 4 5 6 7)

(let [bar (+ 7 2)] `(fn [bar#] (* ~bar 3)))

(clojure.core/fn [bar__1370717__auto__] (clojure.core/* 9 3))

(let [f (fn [x & y] x)] (apply f (range 1000000)))

0

(let [x 5]
  (letfn [(foo [arg1] (* arg1 x))]
    (foo 2)))

10

(let [a (atom 1)
      b @a]
  (swap! a inc)
  [@a b])

[2 1]

(let [a (identity 25.0) b (identity (float 25.0))] (= a b))

true

(let [meth #(.indexOf %1 %2)]
  (-> "hello"
      (meth (int \e))))

1

(let [target-var #'inc f 'swap!] `[~target-var (var ~f) (atom ~f)])

[#'clojure.core/inc (var swap!) (clojure.core/atom swap!)]

(let [[f & a] (list * 5 3)] (apply f a))

15

(let [x '(vsubgraph blah)] (meta (second `(foo ^List ~x))))

{:column 10, :line 1}

(let [xs (cons 1 (lazy-seq (println "forced") '(2)))] (first xs))

1

(let [a (hash-map Double/NaN 1)] (identical? (assoc a Double/NaN 2) a))

false

(let [code '(blah)] `(try ~@code (catch Exception e "Oops")))

(try blah (catch java.lang.Exception user/e "Oops"))

(let [x [1 2 3]] `[a b ~@x c d])

[user/a user/b 1 2 3 user/c user/d]

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

[1 2]

(let [{:keys [a b]} {:a 1, :b 1}] (+ a b))

2

(defmacro foo [x] (let [y (map inc x)] `(prn ~@y)))

#'user/foo

(let [l ^{:type :thing} (list 1 2 3)] (meta l))

nil

(let [foo {:my-fn (fn [x] (* x x))}] ((:my-fn foo) 5))

25

(type (let [x (cons 4 '(3 2 1))] (rest x)))

clojure.lang.PersistentList

(defn set-seq [s] (let [iter (.iterator s)] (repeatedly #(.next iter))))

#'user/set-seq

(let [s [1 2 3]] [(apply + s) (reduce + s)])

[6 6]

(let [m {:name "my-job-flow", :log-uri "s3n://emr-logs/logs"}]
  (apply str (apply concat m)))

":namemy-job-flow:log-uris3n://emr-logs/logs"

(defmacro contrived-let [vecx & body] `(let [~@(rest vecx)] ~@body))

#'user/contrived-let

(let [{a "hello", b "world"} {"hello" 0, "world" 42}] [a b])

[0 42]

(let [intern (memoize identity)]
  (identical? (intern "test") (intern (str "te" "st"))))

true

(let [{:keys [foo bar]} [:foo 'a :bar 'b]] (prn foo bar))

nil

"nil nil\n"

(let [L (with-meta '(a b) {:foo :bar})] (meta (next L)))

nil

(let [[f & r] #{10 20 30}] (println f r))

nil

"20 (30 10)\n"

(defn times-n [n] (let [x n] (fn [y] (* y x))))

#'user/times-n

(let [{:keys [a b], :or {:b 3}} {:a 1}] [a b])

[1 nil]

(let [name "test"
      a (atom {})]
  (swap! a assoc :name name)
  name)

"test"

(let [[f & r] (seq #{2 3 4})] [f r])

[4 (3 2)]

(let [v [7 9]] (apply disj (set (range 1 12)) v))

#{1 2 3 4 5 6 8 10 11}

(let [thingy {:a 2, :b 5}] (* (thingy :a) (thingy :b)))

10

(defn make-counter [initial] (let [c (atom initial)] (fn [] (swap! c inc))))

#'user/make-counter

(macroexpand (let [method 'foo] `(~(symbol (str "." method)) bar)))

(.foo user/bar)

(let [x {:a 1} y (assoc x :a 2)] [x y])

[{:a 1} {:a 2}]

(let [xs '(1 2 3) [x y z] xs] y)

2

(let [afn (fn [i] (inc i))] (map afn [1 2 3]))

(2 3 4)

(let [a 5 b (+ a 5)] {:a a, :b b})

{:a 5, :b 10}

(let [* #(apply * (conj %& 2))] (* 2 2))

8

(let [title '(str "I'm a" "title")] `(.setTitle frame# ~title))

(user/.setTitle frame__3430261__auto__ (str "I'm a" "title"))