          (core/let [form (first forms)
                     threaded (if (seq? form)
                                (with-meta `(~(first form) ~x ~@(next form)) (meta form))
-                               (list form x))]
+                               (core/list form x))]
            (recur threaded (next forms)))
          x))))
 
 (core/defn- ^{:dynamic true} assert-valid-fdecl
   "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn."
   [fdecl]
-  (when (empty? fdecl)
+  (core/when (empty? fdecl)
     (throw
       #?(:clj  (IllegalArgumentException. "Parameter declaration missing")
          :cljs (js/Error. "Parameter declaration missing"))))

  (assert-args for
    (vector? seq-exprs) "a vector for its binding"
    (even? (count seq-exprs)) "an even number of forms in binding vector")
  (core/let [to-groups (fn [seq-exprs]
                         (reduce (fn [groups [k v]]
                                   (if (core/keyword? k)
                                     (conj (pop groups) (conj (peek groups) [k v]))
                                     (conj groups [k v])))
                           [] (partition 2 seq-exprs)))
             err (fn [& msg] (throw (ex-info (apply core/str msg) {})))
             emit-bind (fn emit-bind [[[bind expr & mod-pairs]
                                       & [[_ next-expr] :as next-groups]]]
                         (core/let [giter (gensym "iter__")
                                    gxs (gensym "s__")
                                    do-mod (fn do-mod [[[k v :as pair] & etc]]
                                             (core/cond
                                               (= k :let) `(let ~v ~(do-mod etc))
                                               (= k :while) `(when ~v ~(do-mod etc))

    :arglists '([name doc-string? attr-map? [params*] body]
                [name doc-string? attr-map? ([params*] body)+ attr-map?])
    :macro true}
  defmacro (core/fn [&form &env
                name & args]
             (core/let [prefix (core/loop [p (core/list (vary-meta name assoc :macro true)) args args]
                                 (core/let [f (first args)]
