(let [[a b] '(1 2)] b)
2
(try (let [a (keys [1])] a :ok))
:ok
(let [baz 4] `(foo bar ~baz))
(user/foo user/bar 4)
(macroexpand '(let [{x :x} :in] :out))
(let [{x :x} :in] :out)
(let [bar [1 2]] `(foo ~bar))
(user/foo [1 2])
(let [[x y] ((fn [] [1 2]))] y)
2
(= (let [[a b] [1]] b) nil)
true
(let [x (fn [] `(prn 1))] (x))
(clojure.core/prn 1)
(let [x (promise)] (deliver x 10) @x)
10
(defmacro ☃ [& stuff] `(let ~@stuff))
#'user/☃
(let [[a b] [1 2]] [a b])
[1 2]
(let [q '[(a b) ()]] (first q))
(a b)
(let [r (atom 0)] (swap! r inc))
1
(let [[x :as all] nil] [x all])
[nil nil]
(let [f 1] (macroexpand-1 `(inc f)))
(clojure.core/inc user/f)
(let [foo "1.2.3"] (into [] (.split foo "\\.")))
["1" "2" "3"]
(let [m {1 2, 3 4}] [(seq m) (first m) (let [[k v] (first m)] [k v])])
[([1 2] [3 4]) [1 2] [1 2]]
(let [create-counter (fn [] (let [cnt (atom 0)] (fn [] (swap! cnt inc)))) counter (create-counter)] (repeatedly 10 counter))
(1 2 3 4 5 6 7 8 9 10)
(def cmp-prev (let [prv (atom nil)] (fn [nxt] (let [retval (< @prv nxt)] (reset! prv nxt) retval))))
#'user/cmp-prev
(let [state-sym (gensym "state") eqns-kv `(blah (+ ~state-sym 2))] `(fn [~state-sym] (let [~@eqns-kv] ...)))
(clojure.core/fn [state118244] (clojure.core/let [user/blah (clojure.core/+ state118244 2)] user/...))
(defmacro with-out-str-and-value [& body] `(let [s# (new java.io.StringWriter)] (binding [*out* s#] (let [v# ~@body] [(str s#) v#]))))
#'user/with-out-str-and-value
(let [pair [double :a] m {:a 1, :b 2}] (let [[f k] pair] (f (get m k))))
1.0
(let [f #(do (println 1) 2) sw (java.io.StringWriter.)] (binding [*out* sw] (let [x (f)] (str sw x))))
"1\n2"
(defmacro silly-recur [& args] (let [syms (map (fn [_] (gensym)) args)] `(let [~@syms (process [~@args])] (recur ~@syms))))
#'user/silly-recur
(let [[x y] [1 2]] (+ 1 2))
3
(let [{:keys [name]} {:name "Joe", :age 30}] name)
"Joe"
(macroexpand-1 '(let [{{bar :bar} :foo} x] bar))
(let [{{bar :bar} :foo} x] bar)
(let [[_ {:keys [something]}] [:keyword {:key "value"}]] something)
nil
(let [{{a :b} :a} {:a {:b 'c}}] a)
c
(let [x (new Object)] (= x (new Object)))
false
(let [{[bar _] :foo} {:foo [1 2]}] bar)
1
(let [f (fn [x] x)] ({f :foo} f))
:foo
(let [a (range 3)] `(:foo ~a :bar))
(:foo (0 1 2) :bar)
(println (quote #(let [_ %&] (foo %1))))
nil
"(fn* [%1 & %&] (let [_ %&] (foo %1)))\n"
(let [foo nil] (when foo (.write foo "hi")))
nil
(let [pair {:x 10, :y 11}] (pair :x))
10
(let [a 4 b (inc a)] [a b])
[4 5]
(let [m {1 (promise)}] (get m 1) nil)
nil
(let [a (delay (+ 1 2))] (force a))
3
(let [a (atom true)] (println a) (println @a))
nil
"#object[clojure.lang.Atom 0x56d66b93 {:status :ready, :val true}]\ntrue\n"
(macroexpand (let [[x y] (range 2)] x))
0
(let [opts {:a 1, :b 2}] (opts :a))
1
(let [f (partial + 1 1)] (f 7))
9
(#(let [& 1 % 2] %&) 3)
nil
(let [[a b] [1 2]] (print a b))
nil
"1 2"
(let [x 42] [[x x] '[x x]])
[[42 42] [x x]]
(let [f inc x 1] `((~f ~x)))
((#object [clojure.core$inc 0x4e7bae5c "clojure.core$inc@4e7bae5c"] 1))
(let [x (promise)] (deliver x inc) (x 2))
nil
(let [col [1 2 3]] (interleave col col))
(1 1 2 2 3 3)
(let [[k v] (seq {:key 'val})] [k v])
[[:key val] nil]