            (or *load-configuration*
                {:debug? false})))
 
-  ([form {:keys [debug? exec? ast env classloader]
-          :or   {exec? true
-                 debug? false}
-          :as options}]
-     (let [defs-ast  (:defs ast)
-           forms-ast (:forms ast)
-           mform     (binding [macroexpand-1 ana.jvm/macroexpand-1]
-                       (macroexpand form (or env
-                                             (ana.jvm/empty-env))))]
+  ([form {:keys [debug? exec? forms env classloader]
+          :or   {debug? false}
+          :as   options}]
+     (let [mform (binding [macroexpand-1 ana.jvm/macroexpand-1]
+                   (macroexpand form
+                                (or env (ana.jvm/empty-env))))]
 
        (if (and (seq? mform)
                 (= 'do (first mform)))

         ;;   answer is no, but it'd be nice.

         ;; FIXME: Closed over defs
         ;;  This is gonna be invalid for a whole lot of code. Lambda
         ;;  lifting is gonna come into play here methinks. I have to
         ;;  get this working so that closed over defs are supported,
         ;;  eg:
         ;;
         ;;  (let [x 3]
         ;;    (def foo [y]
         ;;         (+ x y)))
         ;;
         ;; This issue also impacts multimethods which are implemented
         ;; with closed over defs.

         (let [ast   (binding [ana/macroexpand-1 ana.jvm/macroexpand-1
                               ana/create-var    ana.jvm/create-var
                               ana/parse         ana.jvm/parse
                               ana/var?          var?]
                       (ana.jvm/analyze mform
                                        (or env (ana.jvm/empty-env))))]

           ;; the accumulator for the whole read program
           (when (and forms-ast
                      (atom? forms-ast))
             (swap! forms-ast conj ast))

           ;; the accumulator for defs to structure
           (when (and defs-ast
                      (atom? defs-ast)
                      (patern/def? ast))
             (swap! defs-ast assoc
                    (patern/def->symbol ast)
                    ast))

           ;; FIXME: Eval for side effects
           ;;  Running code for side-effects may be something that I
           ;;  need to conditionalize, see "Closed over defs"

           ;; and run the code for side-effects.
           (let [r     (-> `(^:once fn* [] ~mform)
                           (ana.jvm/analyze (or env (ana.jvm/empty-env)))
                           (e/emit {:debug?       debug?
                                    :class-loader (or classloader
                                                      (clojure.lang.RT/makeClassLoader))}))
                 class (-> r meta :class)]
             (.invoke ^IFn (.newInstance ^Class class))))))))


(defn load

       ;;   the mailing list.
       (let [settings (:passes settings)]
         (doseq [pass passes]
           (swap! forms pass settings)

           (let [eval-forms @forms]
             (reset! forms [])

             (doseq [form eval-forms]
               (eval (:form form)
