(let [foo "1.2.3"] (into [] (.split foo ".")))
[]
(let [!' (fn [x] x)] (!' 1))
1
(let [overrides {:foo :overridden}] (:foo overrides :default))
:overridden
(let [x (first [1 2 3])] x)
1
(let [x {}] (meta ^{:my :Meta} x))
nil
(let [x (int 1234)] (< x 4321))
true
(let [x [1 2 3]] `(~@x))
(1 2 3)
(let [[& xs] [1 2 3]] xs)
(1 2 3)
(let [x 2 y (* x 2)])
nil
(let [a "3"] (case a "3" "ETT"))
"ETT"
(let [[a & b] [1]] [a b])
[1 nil]
(let [[x & xs] (lazy-seq 1 ())] xs)
nil
(let [x (short 0)] ({0 "zero"} x))
"zero"
(->> (+ x 1) (let [x 5]))
6
(let [foo false] (if foo "truthy" "falsy"))
"falsy"
(let [x (map prn (range 2000))] "foo")
"foo"
(let [xs (map println (range 10))] 1)
1
(let [[{a :a}] [(seq [:a :A])]] a)
:A
(macroexpand '(let (a b) (c d)))
(let (a b) (c d))
(let [[& {a :a}] [:a 0]] a)
0
(let [y 3] '(+ y 1))
(+ y 1)
(let [shadow "shadow"] (str shadow " puppets"))
"shadow puppets"
(let [[a b c] [1 2 3]])
nil
(let [x 1 x’ (inc x)] x’)
2
(defmacro foo [] (let [f 1] (prn &env)))
#'user/foo
(let [n (do (println "hello") nil)] 10)
10
"hello\n"
(let [x filter] (:doc (meta (var x))))
nil
(let [[a b] (iterate inc 1)] a)
1
(let [identity (comp clojure.repl/demunge munge)] (identity "_"))
"-"
(let [x 4 (comment y 5)] x)
4
(defmacro afunc [input] `(let [escape ~input]))
#'user/afunc
(let [?'! (fn [x] x)] (?'! 1))
1
(let [a 2 b (delay a)] @b)
2
(let [x (Exception. "foo")] (with-out-str (.printStackTrace x)))
""
(let [[a :as numbers] (range 5)] a)
0
(macroexpand `(let [x 1] (println x)))
(clojure.core/let [user/x 1] (clojure.core/println user/x))
(let [x (identity Double/NaN)] (= x x))
true
(macroexpand '(let [x 12] (inc x)))
(let [x 12] (inc x))
(let [x 3] (eval `{:a ~x}))
{:a 3}
(macroexpand '(-> [a 5] (let a)))
(let [a 5] a)
(let [almost-curried (partial + 1)] (almost-curried 1))
2
(let [x (if true :a :b)] x)
:a
(let [a 'G__1963] (prn (gensym)) (prn a))
nil
"G__1238078\nG__1963\n"
(def *foo* ((fn [] (let [foo :foo] foo))))
#'user/*foo*
(let [^"[Ljava.lang.String" s "whee"] (vec s))
[\w \h \e \e]
(let [if 10 do 20] (do if))
10
(let [a '(1 1)] `(~@a))
(1 1)
(let [if 12] (list if true :true))
(12 true :true)
(read-string "(let [foo. 5] foo.)")
(let [foo. 5] foo.)
(let [a 1 b 2] [a b])
[1 2]