   ([] nil)
   ([x] x)
   ([x & next]
-      `(let [or# ~x]
-         (if or# or# (or ~@next)))))
+    (let [forms (concat [x] next)]
+      (if (every? simple-bool-expr?
+            (map #(cljs.analyzer/analyze &env %) forms))
+        (let [or-str (->> (repeat (count forms) "~{}")
+                        (interpose " || ")
+                        (apply core/str))]
+          (bool-expr `(~'js* ~or-str ~@forms)))
+        `(let [or# ~x]
+           (if or# or# (or ~@next)))))))
 
 (defmacro nil? [x]
   `(coercive-= ~x nil))

                            bit-test bit-shift-left bit-shift-right bit-xor

                            cond-> cond->> as-> some-> some->>])
  (:require clojure.walk))

(alias 'core 'clojure.core)


(defn bool-expr [e]
  (vary-meta e assoc :tag 'boolean))

(defn simple-bool-expr? [ast]
  (core/and
    (#{:var :invoke :constant :dot} (:op ast))
    (= (cljs.compiler/infer-tag ast) 'boolean)))

(defmacro and
  "Evaluates exprs one at a time, from left to right. If a form
  returns logical false (nil or false), and returns that value and
