[Cleanup]

- Removed a lot of useless comments & logging.
- Removed the useless test1.lux file.

6 files changed, 202 insertions, 604 deletions

diff --git a/src/example/test1.lux b/src/example/test1.lux
deleted file mode 100644
index 8e740eabd..000000000
--- a/src/example/test1.lux
+++ /dev/null
@@ -1,38 +0,0 @@
-
-(* 5 6)
-
-## My first function definition!
-(def (repeat n val)
-  (if (<=' n 0)
-    (#Nil [])
-    (#Cons [val (repeat (-' n 1) val)])))
-
-## Testing one, two, three...
-(repeat 5 5)
-
-(def (fold f init inputs)
-  (case inputs
-    #( Outer comment #( Inner comment )# )#
-    (#Nil [])            init
-    (#Cons [head tail]) (fold f (f init head) tail)))
-
-## It's alive!
-(fold * 1 (repeat 5 5))
-
-3.14
-
-(def pi 3.14)
-
-pi
-
-(def (foo x)
-  (let [y (*' 2 x)]
-    (+' x y)))
-
-(foo 10)
-
-(def bar {#x 10 #y 20})
-bar
-(get@ #x bar)
-(set@ #z 30 bar)
-(remove@ #y bar)
diff --git a/src/lux.clj b/src/lux.clj
index dca7034c3..7553e1845 100644
--- a/src/lux.clj
+++ b/src/lux.clj
@@ -22,8 +22,9 @@
   ;; TODO: Add "new". Allow setting fields.
   ;; TODO: monitor enter & monitor exit.
   ;; TODO: Reinplement "if" as a macro on top of case.
+  ;; TODO: Remember to optimized calling global functions.
   ;; TODO: 
-
+  
   (&compiler/compile-all ["lux" "test2"])
 
   
diff --git a/src/lux/analyser.clj b/src/lux/analyser.clj
index 179d2089e..ce84c7310 100644
--- a/src/lux/analyser.clj
+++ b/src/lux/analyser.clj
@@ -46,12 +46,6 @@
 
 (defn ^:private is-macro? [module name]
   (fn [state]
-    ;; (prn 'is-macro? (nth name 1)
-    ;;      (get-in state [:defs (:name state) (nth name 1) :mode])
-    ;;       (= (get-in state [:defs (:name state) (nth name 1) :mode]) ::macro))
-    ;; (prn 'is-macro? name (get-in state [:modules module name :mode])
-    ;;      (get-in state [:modules module])
-    ;;      (get-in state [:modules]))
     [::&util/ok [state (= (get-in state [:modules module name :mode]) ::macro)]]))
 
 (def ^:private next-local-idx
@@ -68,12 +62,7 @@
 
 (defn ^:private in-scope? [module name]
   (fn [state]
-    (do ;; (prn 'in-scope?
-        ;;      ?macro-name
-        ;;      (get-in state [:lambda-scope 0])
-        ;;      (some (partial = ?macro-name) (get-in state [:lambda-scope 0])))
-        [::&util/ok [state (some (partial = name) (get-in state [:lambda-scope 0]))]])
-    ))
+    [::&util/ok [state (some (partial = name) (get-in state [:lambda-scope 0]))]]))
 
 (defn with-scope [scope body]
   (fn [state]
@@ -103,17 +92,14 @@
 
 (defn ^:private with-lambda-scope [body]
   (fn [state]
-    (let [;; _ (prn 'with-lambda-scope (get-in state [:lambda-scope 0]) (get-in state [:lambda-scope 1]))
-          =return (body (-> state
+    (let [=return (body (-> state
                             (update-in [:lambda-scope 0] conj (get-in state [:lambda-scope 1]))
                             (assoc-in [:lambda-scope 1] 0)))]
       (match =return
         [::&util/ok [?state ?value]]
-        [::&util/ok [(do ;; (prn [:lambda-scope 0] (get-in ?state [:lambda-scope 0]))
-                         ;; (prn [:lambda-scope 1] (get-in ?state [:lambda-scope 1]))
-                         (-> ?state
-                             (update-in [:lambda-scope 0] pop)
-                             (assoc-in [:lambda-scope 1] (inc (get-in state [:lambda-scope 1])))))
+        [::&util/ok [(-> ?state
+                         (update-in [:lambda-scope 0] pop)
+                         (assoc-in [:lambda-scope 1] (inc (get-in state [:lambda-scope 1]))))
                      ?value]]
         
         _
@@ -130,18 +116,13 @@
                                               (update-in [:counter] inc)
                                               (assoc-in [:mappings name] (annotated [::local (:id (first %)) (:counter (first %))] type)))
                                           (rest %))))]
-      ;; =return
       (match =return
         [::&util/ok [?state ?value]]
-        (do ;; (prn 'POST-WITH-LOCAL name (-> ?state :env first))
-            [::&util/ok [(update-in ?state [:env] #(cons (-> (first %)
-                                                             (update-in [:counter] dec)
-                                                             (update-in [:mappings] dissoc name))
-                                                         (rest %)))
-                         ;; (update-in ?state [:env] (fn [[top & oframes]]
-                         ;;                            (prn 'NEW-FRAMES name (cons (-> state :env first (assoc :closure (-> top :closure))) oframes))
-                         ;;                            (cons (-> state :env first (assoc :closure (-> top :closure))) oframes)))
-                         ?value]])
+        [::&util/ok [(update-in ?state [:env] #(cons (-> (first %)
+                                                         (update-in [:counter] dec)
+                                                         (update-in [:mappings] dissoc name))
+                                                     (rest %)))
+                     ?value]]
         
         _
         =return)
@@ -153,10 +134,9 @@
                                                         (rest %))))]
       (match =return
         [::&util/ok [?state ?value]]
-        (do ;; (prn 'POST-WITH-LOCAL name (-> ?state :env first))
-            [::&util/ok [(update-in ?state [:env] #(cons (update-in (first %) [:mappings] (fn [m] (apply dissoc m (keys mappings))))
-                                                         (rest %)))
-                         ?value]])
+        [::&util/ok [(update-in ?state [:env] #(cons (update-in (first %) [:mappings] (fn [m] (apply dissoc m (keys mappings))))
+                                                     (rest %)))
+                     ?value]]
         
         _
         =return))))
@@ -164,7 +144,6 @@
 (defn ^:private with-fresh-env [[args-vars args-types] body]
   (with-lambda-scope
     (fn [state]
-      ;; (prn '(:env state) (:env state) (-> state :env first :id inc))
       (let [state* (update-in state [:env]
                               (fn [outer]
                                 (let [frame-id (-> outer first :id inc)
@@ -175,22 +154,13 @@
                                                       (update-in (fresh-env frame-id) [:counter] inc)
                                                       (map vector args-vars args-types))]
                                   (conj outer new-top))))
-            =return (body state*)
-            ;; _ (prn '=return =return)
-            ]
+            =return (body state*)]
         (match =return
           [::&util/ok [?state ?value]]
-          (do ;; (prn 'PRE-LAMBDA (:env state))
-              ;; (prn 'POST-LAMBDA (:env ?state) ?value)
-              ;; (prn 'POST-LAMBDA1 (get-in ?state [:lambda-scope 0]) (-> ?state :env first :mappings))
-              ;; (prn 'POST-LAMBDA2 (get-in ?state [:lambda-scope 0]) (-> ?state :env first (update-in [:mappings] #(reduce dissoc % args-vars)) :mappings))
-              [::&util/ok [(-> ?state
-                               (update-in [:env] rest)
-                               ;; (update-in [:lambda-scope 1] inc)
-                               )
-                           [(get-in ?state [:lambda-scope 0])
-                            (-> ?state :env first (update-in [:mappings] #(reduce dissoc % args-vars)))
-                            ?value]]])
+          [::&util/ok [(update-in ?state [:env] rest)
+                       [(get-in ?state [:lambda-scope 0])
+                        (-> ?state :env first (update-in [:mappings] #(reduce dissoc % args-vars)))
+                        ?value]]]
           
           _
           =return)))))
@@ -208,7 +178,6 @@
                  nil]]))
 
 (defn ^:private close-over [scope ident register frame]
-  ;; (prn 'close-over scope ident register)
   (let [register* (annotated [::captured scope (:closure/id frame) register] (:type register))]
     [register* (-> frame
                    (update-in [:closure/id] inc)
@@ -218,38 +187,29 @@
   (fn [state]
     (or (if-let [[_ ?alias ?binding] (re-find #"^(.*)/(.*)$" ident)]
           (if-let [?module (get-in state [:deps ?alias])]
-            (do (prn 'resolve '[_ ?alias ?binding] ident [:global ?module ?binding])
-              [::&util/ok [state (annotated [::global ?module ?binding] ::&type/nothing)]])))
+            [::&util/ok [state (annotated [::global ?module ?binding] ::&type/nothing)]]))
         (let [[inner outer] (split-with #(nil? (get-in % [:mappings ident])) (:env state))]
           (cond (empty? inner)
-                (do ;; (prn 'resolve/inner ident (get-in state [:lambda-scope 0]))
-                    (prn 'resolve/env ident (-> state :env first :mappings (get ident)))
-                  [::&util/ok [state (-> state :env first :mappings (get ident))]])
+                [::&util/ok [state (-> state :env first :mappings (get ident))]]
                 
                 (empty? outer)
-                (do ;; (prn 'resolve/outer ident (get-in state [:lambda-scope 0]))
-                  (if-let [global|import (or (get-in state [:defs-env ident])
-                                             (get-in state [:imports ident]))]
-                    (do (prn 'resolve/global|import ident global|import)
-                      [::&util/ok [state global|import]])
-                    (do (prn 'resolve/UNRESOLVED (str "Unresolved identifier: " ident))
-                      [::&util/failure (str "Unresolved identifier: " ident)])))
+                (if-let [global|import (or (get-in state [:defs-env ident])
+                                           (get-in state [:imports ident]))]
+                  [::&util/ok [state global|import]]
+                  [::&util/failure (str "Unresolved identifier: " ident)])
 
                 :else
-                (do ;; (prn 'resolve/:else ident (get-in state [:lambda-scope 0]))
-                  (let [[=local inner*] (reduce (fn [[register new-inner] [frame scope]]
-                                                  (let [[register* frame*] (close-over scope ident register frame)]
-                                                    [register* (cons frame* new-inner)]))
-                                                [(-> outer first :mappings (get ident)) '()]
-                                                (map vector
-                                                     (reverse inner)
-                                                     (->> (get-in state [:lambda-scope 0])
-                                                          (iterate pop)
-                                                          (take (count inner))
-                                                          reverse)))]
-                    ;; (prn 'resolve/inner* inner*)
-                    (prn 'resolve/=local ident =local)
-                    [::&util/ok [(assoc state :env (concat inner* outer)) =local]])))))))
+                (let [[=local inner*] (reduce (fn [[register new-inner] [frame scope]]
+                                                (let [[register* frame*] (close-over scope ident register frame)]
+                                                  [register* (cons frame* new-inner)]))
+                                              [(-> outer first :mappings (get ident)) '()]
+                                              (map vector
+                                                   (reverse inner)
+                                                   (->> (get-in state [:lambda-scope 0])
+                                                        (iterate pop)
+                                                        (take (count inner))
+                                                        reverse)))]
+                  [::&util/ok [(assoc state :env (concat inner* outer)) =local]]))))))
 
 (defmacro ^:private defanalyser [name match return]
   `(def ~name
@@ -261,19 +221,15 @@
          (fail* (str "Unmatched token: " token#))))))
 
 (defn analyse-form* [form]
-  ;; (prn 'analyse-form* form)
   (fn [state]
     (let [old-forms (:forms state)
-          =return (analyse-form (assoc state :forms (list form)))
-          ;; _ (prn 'analyse-form*/=return =return)
-          ]
+          =return (analyse-form (assoc state :forms (list form)))]
       (match =return
         [::&util/ok [?state ?value]]
         [::&util/ok [(assoc ?state :forms old-forms) ?value]]
         
         [::&util/failure ?message]
-        (do ;; (prn 'analyse-form* ?message)
-          [::&util/failure ?message])))))
+        [::&util/failure ?message]))))
 
 (do-template [<name> <tag> <class>]
   (defanalyser <name>
@@ -307,18 +263,7 @@
 
 (defanalyser analyse-ident
   [::&parser/ident ?ident]
-  ;; (exec [_env (fn [state] [::&util/ok [state (:env state)]])
-  ;;        ;; :let [_ (prn 'analyse-ident ?ident _env)]
-  ;;        ]
-  ;;   (resolve ?ident))
-  (exec [;; :let [_ (prn 'analyse-ident '?ident ?ident)]
-         =ident (resolve ?ident)
-         ;; :let [_ (prn 'analyse-ident '=ident =ident)]
-         ;; :let [_ (prn 'analyse-ident ?ident =ident)]
-         ;; state &util/get-state
-         ;; :let [_ (prn 'analyse-ident ?ident (:form =ident) (:env state))]
-         ]
-    (return =ident)))
+  (resolve ?ident))
 
 (defanalyser analyse-access
   [::&parser/static-access ?target ?member]
@@ -336,7 +281,6 @@
     (fail "")))
 
 (defn full-class [class]
-  ;; (prn 'full-class-name class)
   (case class
     "boolean" (return Boolean/TYPE)
     "byte"    (return Byte/TYPE)
@@ -349,9 +293,7 @@
     ;; else
     (if (.contains class ".")
       (return (Class/forName class))
-      (try-all-m [(exec [=class (resolve class)
-                         ;; :let [_ (prn '=class =class)]
-                         ]
+      (try-all-m [(exec [=class (resolve class)]
                     (match (:form =class)
                       [::class ?full-name]
                       (return (Class/forName ?full-name))
@@ -371,11 +313,7 @@
     (full-class ?ident)
 
     [::&parser/form ([[::&parser/ident "Array"] [::&parser/ident ?inner]] :seq)]
-    (exec [;; :let [_ (prn '?inner ?inner)]
-           =inner (full-class ?inner)
-           ;; :let [_ (prn '=inner =inner)
-           ;;       _ (prn '(.getName =inner) (.getName =inner))]
-           ]
+    (exec [=inner (full-class ?inner)]
       (return (Class/forName (str "[L" (.getName =inner) ";"))))
 
     _
@@ -398,11 +336,7 @@
     (fail "")))
 
 (defn lookup-field [mode target field]
-  ;; (prn 'lookup-field mode target field)
   (if-let [[[owner type]] (seq (for [=field (.getFields (Class/forName target))
-                                     ;; :let [_ (prn target (.getName =field) (if (java.lang.reflect.Modifier/isStatic (.getModifiers =field))
-                                     ;;                                         :static
-                                     ;;                                         :dynamic))]
                                      :when (and (= field (.getName =field))
                                                 (case mode
                                                   :static (java.lang.reflect.Modifier/isStatic (.getModifiers =field))
@@ -413,11 +347,7 @@
     (fail (str "Field does not exist: " target field mode))))
 
 (defn lookup-method [mode target method args]
-  ;; (prn 'lookup-method mode target method args)
   (if-let [methods (seq (for [=method (.getMethods (Class/forName target))
-                              ;; :let [_ (prn target (.getName =method) (if (java.lang.reflect.Modifier/isStatic (.getModifiers =method))
-                              ;;                                          :static
-                              ;;                                          :dynamic))]
                               :when (and (= method (.getName =method))
                                          (case mode
                                            :static (java.lang.reflect.Modifier/isStatic (.getModifiers =method))
@@ -440,25 +370,19 @@
     (fail (str "Field does not exist: " target field))))
 
 (defn lookup-virtual-method [target method-name args]
-  ;; (prn 'lookup-virtual-method target method-name args)
   (if-let [method (first (for [=method (.getMethods target)
                                :when (and (= target (.getDeclaringClass =method))
                                           (= method-name (.getName =method))
                                           (not (java.lang.reflect.Modifier/isStatic (.getModifiers =method))))]
                            =method))]
-    (do ;; (prn 'lookup-virtual-method 'method method)
-      (exec [=method (&type/method->type method)]
-        (&type/return-type =method)))
-    (do ;; (prn 'lookup-virtual-method (str "Virtual method does not exist: " target method-name))
-      (fail (str "Virtual method does not exist: " target method-name)))))
+    (exec [=method (&type/method->type method)]
+      (&type/return-type =method))
+    (fail (str "Virtual method does not exist: " target method-name))))
 
 (defn full-class-name [class]
-  ;; (prn 'full-class-name class)
   (if (.contains class ".")
     (return class)
-    (try-all-m [(exec [=class (resolve class)
-                       ;; :let [_ (prn '=class =class)]
-                       ]
+    (try-all-m [(exec [=class (resolve class)]
                   (match (:form =class)
                     [::class ?full-name]
                     (return ?full-name)
@@ -483,8 +407,6 @@
   (exec [=class (full-class-name ?class)
          =classes (map-m extract-jvm-param ?classes)
          =return (lookup-virtual-method (Class/forName =class) ?method =classes)
-         ;; :let [_ (prn 'analyse-jvm-invokevirtual ?class ?method  =classes '-> =return)]
-         ;; =return =return
          =object (analyse-form* ?object)
          =args (map-m analyse-form* ?args)]
     (return (annotated [::jvm-invokevirtual =class ?method (map #(.getName %) =classes) =object =args] =return))))
@@ -512,45 +434,7 @@
   (exec [=array (analyse-form* ?array)]
     (return (annotated [::jvm-aaload =array ?idx] (-> =array :type (nth 1))))))
 
-;; (defanalyser analyse-access
-;;   [::&parser/access ?object ?member]
-;;   (match ?member
-;;     [::&parser/ident ?field] ;; Field
-;;     (try-all-m [(exec [?target (extract-ident ?object)
-;;                        =target (resolve ?target)
-;;                        ?class (extract-class (:form =target))
-;;                        [=owner =type] (lookup-field :static ?class ?field)
-;;                        ;; :let [_ (prn '=type =type)]
-;;                        ]
-;;                   (return (annotated [::static-field =owner ?field] =type)))
-;;                 (exec [=target (analyse-form* ?object)
-;;                        ?class (class-type (:type =target))
-;;                        [=owner =type] (lookup-field :dynamic ?class ?field)
-;;                        ;; :let [_ (prn '=type =type)]
-;;                        ]
-;;                   (return (annotated [::dynamic-field =target =owner ?field] =type)))])
-;;     [::&parser/fn-call [::&parser/ident ?method] ?args] ;; Method
-;;     (exec [=args (map-m analyse-form* ?args)]
-;;       (try-all-m [(exec [?target (extract-ident ?object)
-;;                          =target (resolve ?target)
-;;                          ?class (extract-class (:form =target))
-;;                          =methods (lookup-method :static ?class ?method (map :type =args))
-;;                          ;; :let [_ (prn '=methods =methods)]
-;;                          [=owner =method] (within :types (&type/pick-matches =methods (map :type =args)))
-;;                          ;; :let [_ (prn '=method =owner ?method =method)]
-;;                          ]
-;;                     (return (annotated [::static-method =owner ?method =method =args] (&type/return-type =method))))
-;;                   (exec [=target (analyse-form* ?object)
-;;                          ?class (class-type (:type =target))
-;;                          =methods (lookup-method :dynamic ?class ?method (map :type =args))
-;;                          ;; :let [_ (prn '=methods =methods)]
-;;                          [=owner =method] (within :types (&type/pick-matches =methods (map :type =args)))
-;;                          ;; :let [_ (prn '=method =owner ?method =method)]
-;;                          ]
-;;                     (return (annotated [::dynamic-method =target =owner ?method =method =args] (&type/return-type =method))))]))))
-
 (defn ->token [x]
-  ;; (prn '->token x)
   (match x
     [::&parser/bool ?bool]
     (doto (.newInstance (.loadClass @loader "lux.Variant1"))
@@ -592,7 +476,6 @@
 
 (defn ->tokens [xs]
   (reduce (fn [tail x]
-            ;; (prn 'tail (.-tag tail) 'x x)
             (doto (.newInstance (.loadClass @loader "lux.Variant2"))
               (-> .-tag (set! "Cons"))
               (-> .-_1 (set! (->token x)))
@@ -602,7 +485,6 @@
           (reverse xs)))
 
 (defn ->clojure-token [x]
-  ;; (prn '->clojure-token x (.-tag x))
   (case (.-tag x)
     "Bool"  [::&parser/bool (-> x .-_1)]
     "Int"   [::&parser/int (-> x .-_1)]
@@ -615,7 +497,6 @@
     "Form"  [::&parser/form (-> x .-_1 tokens->clojure)]))
 
 (defn tokens->clojure [xs]
-  ;; (prn 'tokens->clojure xs (.-tag xs))
   (case (.-tag xs)
     "Nil" '()
     "Cons" (cons (->clojure-token (.-_1 xs))
@@ -624,25 +505,17 @@
 
 (defanalyser analyse-call
   [::&parser/form ([?fn & ?args] :seq)]
-  (exec [=fn (analyse-form* ?fn)
-         ;; :let [_ (prn 'analyse-call/=fn =fn)]
-         ]
+  (exec [=fn (analyse-form* ?fn)]
     (match (:form =fn)
       [::global-fn ?module ?name]
       (exec [macro? (is-macro? ?module ?name)
-             scoped? (in-scope? ?module ?name)
-             :let [_ (prn 'analyse-call [:global-fn ?module ?name] macro? scoped?)]
-             ;; :let [_ (prn 'analyse-call [:global-fn ?module ?name] macro? scoped?)]
-             ]
+             scoped? (in-scope? ?module ?name)]
         (if (and macro? (not scoped?))
           (let [macro-class (str ?module "$" (normalize-ident ?name))
                 transformed (-> (.loadClass @loader macro-class)
                                 .newInstance
                                 (.apply (->tokens ?args))
-                                ->clojure-token)
-                _ (prn 'analyse-call/macro-raw ?args)
-                _ (prn 'analyse-call/transformed transformed)
-                ]
+                                ->clojure-token)]
             (-> transformed
                 analyse-form*))
           (exec [=args (map-m analyse-form* ?args)
@@ -652,9 +525,7 @@
                                                         provides-num (count =args)]
                                                     (if (> needs-num provides-num)
                                                       [needs-num [::&type/function (drop provides-num ?fargs) ?freturn]]
-                                                      [needs-num [::&type/object "java.lang.Object" []]])))
-                       ;; _ (prn '[needs-num =return-type] [needs-num =return-type])
-                       ]]
+                                                      [needs-num [::&type/object "java.lang.Object" []]])))]]
             (return (annotated [::static-call needs-num =fn =args] =return-type)))))
 
       _
@@ -665,13 +536,8 @@
 (defanalyser analyse-if
   [::&parser/form ([[::&parser/ident "if"] ?test ?then ?else] :seq)]
   (exec [=test (analyse-form* ?test)
-         ;; :let [_ (prn '=test =test)]
-         ;; :let [_ (prn 'PRE '?then ?then)]
          =then (analyse-form* ?then)
-         ;; :let [_ (prn '=then =then)]
-         =else (analyse-form* ?else)
-         ;; :let [_ (prn '=else =else)]
-         ]
+         =else (analyse-form* ?else)]
     (return (annotated [::if =test =then =else] ::&type/nothing))))
 
 (defanalyser analyse-do
@@ -754,18 +620,12 @@
                    :branches #{}}
       generate-branches (fn generate-branches [data]
                           (let [branches* (reduce fold-branch base-struct data)]
-                            ;; (prn 'generate-branches data)
-                            ;; (prn 'branches* branches*)
-                            ;; (.print System/out (prn-str 'branches* branches*))
-                            ;; (.print System/out (prn-str '(:type branches*) (:type branches*)))
                             (clojure.core.match/match (:type branches*)
                               ::char-tests branches*
                               ::text-tests branches*
                               ::tuple (do (assert (<= (count (:defaults branches*)) 1))
                                         {:type ::tuple*
-                                         :patterns (into {} (for [[?tag ?struct] {nil (:patterns branches*)}
-                                                                  ;; :let [_ (prn '(:patterns branches*) ?tag ?struct)]
-                                                                  ]
+                                         :patterns (into {} (for [[?tag ?struct] {nil (:patterns branches*)}]
                                                               [?tag {:parts (let [grouped-parts (apply map list (for [{:keys [case body]} (:cases ?struct)]
                                                                                                                   (map #(vector % body) case)))]
                                                                               (map generate-branches grouped-parts))
@@ -774,9 +634,7 @@
                                          :branches (:branches branches*)})
                               ::adt (do (assert (<= (count (:defaults branches*)) 1))
                                       {:type ::adt*
-                                       :patterns (into {} (for [[?tag ?struct] (:patterns branches*)
-                                                                ;; :let [_ (prn '(:patterns branches*) ?tag ?struct)]
-                                                                ]
+                                       :patterns (into {} (for [[?tag ?struct] (:patterns branches*)]
                                                             [?tag {:parts (let [grouped-parts (apply map list (for [{:keys [case body]} (:cases ?struct)]
                                                                                                                 (map #(vector % body) case)))]
                                                                             (map generate-branches grouped-parts))
@@ -860,7 +718,6 @@
                        (clojure.core.match/match branch
                          [::case-branch ?pattern ?body]
                          [(->instructions locals ?pattern) ?body]))
-          ;; _ (prn branches**)
           ;; Step 5: Re-structure branching
           ]
       [max-registers branch-mappings (generate-branches branches**)])))
@@ -883,13 +740,9 @@
   (defanalyser analyse-case
     [::&parser/form ([[::&parser/ident "case"] ?variant & ?branches] :seq)]
     (exec [=variant (analyse-form* ?variant)
-           ;; :let [_ (prn 'analyse-case '=variant =variant)]
            $scope scope-id
-           ;; :let [_ (prn 'analyse-case '$scope $scope)]
            $base next-local-idx
-           ;; :let [_ (prn 'analyse-case '$base $base)]
            [registers mappings tree] (exec [=branches (map-m (fn [[?pattern ?body]]
-                                                               ;; (prn '?branch ?branch)
                                                                (match ?pattern
                                                                  [::&parser/char ?token]
                                                                  (exec [=body (analyse-form* ?body)]
@@ -910,26 +763,18 @@
 
                                                                  [::&parser/tuple ?members]
                                                                  (exec [[_ locals+] (reduce-m (locals-getter $scope) [$base {}] ?members)
-                                                                        ;; :let [_ (prn 'analyse-case 'locals+ locals+)]
                                                                         =body (with-locals locals+
-                                                                                (analyse-form* ?body))
-                                                                        ;; :let [_ (prn 'analyse-case '=body =body)]
-                                                                        ]
+                                                                                (analyse-form* ?body))]
                                                                    (return [::case-branch [::&parser/tuple ?members] =body]))
                                                                  
                                                                  [::&parser/form ([[::&parser/tag ?tag] & ?members] :seq)]
                                                                  (exec [[_ locals+] (reduce-m (locals-getter $scope) [$base {}] ?members)
-                                                                        ;; :let [_ (prn 'analyse-case 'locals+ locals+)]
                                                                         =body (with-locals locals+
-                                                                                (analyse-form* ?body))
-                                                                        ;; :let [_ (prn 'analyse-case '=body =body)]
-                                                                        ]
+                                                                                (analyse-form* ?body))]
                                                                    (return [::case-branch [::&parser/variant ?tag ?members] =body]))
                                                                  ))
                                                              (partition 2 ?branches))]
-                                       (return (->decision-tree $scope $base =branches)))
-           ;; :let [_ (prn 'analyse-case '[registers mappings tree] [registers mappings tree])]
-           ]
+                                       (return (->decision-tree $scope $base =branches)))]
       (return (annotated [::case (dec $base) =variant registers mappings tree] ::&type/nothing)))))
 
 (defanalyser analyse-let
@@ -942,8 +787,7 @@
 
 (defanalyser analyse-defclass
   [::&parser/form ([[::&parser/ident "jvm/defclass"] [::&parser/ident ?name] [::&parser/ident ?super-class] [::&parser/tuple ?fields]] :seq)]
-  (exec [;; :let [_ (prn 'analyse-defclass/?fields ?fields)]
-         ?fields (map-m (fn [?field]
+  (exec [?fields (map-m (fn [?field]
                           (match ?field
                             [::&parser/tuple ([[::&parser/ident ?class] [::&parser/ident ?field-name]] :seq)]
                             (return [?class ?field-name])
@@ -951,8 +795,7 @@
                             _
                             (fail "")))
                         ?fields)
-         :let [;; _ (prn 'analyse-defclass/?fields ?fields)
-               =members {:fields (into {} (for [[class field] ?fields]
+         :let [=members {:fields (into {} (for [[class field] ?fields]
                                             [field {:access ::public
                                                     :type class}]))}]
          name module-name]
@@ -960,22 +803,17 @@
 
 (defanalyser analyse-definterface
   [::&parser/form ([[::&parser/ident "jvm/definterface"] [::&parser/ident ?name] & ?members] :seq)]
-  (exec [;; :let [_ (prn 'analyse-definterface/?members ?members)]
-         ?members (map-m #(match %
+  (exec [?members (map-m #(match %
                             [::&parser/form ([[::&parser/ident ":"] [::&parser/ident ?member-name]
                                               [::&parser/form ([[::&parser/ident "->"] [::&parser/tuple ?inputs] [::&parser/ident ?output]] :seq)]]
                                                :seq)]
-                            (exec [;; :let [_ (prn '[?member-name ?inputs ?output] [?member-name ?inputs ?output])]
-                                   ?inputs (map-m extract-ident ?inputs)
-                                   ;; :let [_ (prn '[?member-name ?inputs ?output] [?member-name ?inputs ?output])]
-                                   ]
+                            (exec [?inputs (map-m extract-ident ?inputs)]
                               (return [?member-name [?inputs ?output]]))
                             
                             _
                             (fail ""))
                          ?members)
-         :let [;; _ (prn '?members ?members)
-               =members {:methods (into {} (for [[method [inputs output]] ?members]
+         :let [=members {:methods (into {} (for [[method [inputs output]] ?members]
                                              [method {:access ::public
                                                       :type [inputs output]}]))}
                =interface [::interface ?name =members]]
@@ -995,23 +833,15 @@
 
     [::&parser/form ([[::&parser/ident ?name] & ?args] :seq)]
     (exec [args (map-m extract-ident ?args)
-           ;; :let [_ (prn 'analyse-def/args args)]
            [=function =args =return] (within :types (&type/fresh-function (count args)))
-           ;; :let [_ (prn '[=function =args =return] [=function =args =return])]
-           ;; :let [env (-> {}
-           ;;               (assoc ?name =function)
-           ;;               (into (map vector args =args)))
-           ;;       _ (prn 'env env)]
            =value (with-scope ?name
                     (with-scoped-name ?name =function
                       (reduce (fn [inner [label type]]
                                 (with-local label type inner))
                               (analyse-form* ?value)
                               (reverse (map vector args =args)))))
-           ;; :let [_ (prn '=value =value)]
            =function (within :types (exec [_ (&type/solve =return (:type =value))]
                                       (&type/clean =function)))
-           ;; :let [_ (prn '=function =function)]
            _ (define-fn ?name {:mode   ::function
                                :access ::public
                                :type   =function})]
@@ -1021,19 +851,15 @@
 (defanalyser analyse-defmacro
   [::&parser/form ([[::&parser/ident "defmacro"] [::&parser/form ([[::&parser/ident ?name] [::&parser/ident ?tokens]] :seq)] ?value] :seq)]
   (exec [[=function =tokens =return] (within :types (&type/fresh-function 1))
-         :let [_ (prn 'analyse-defmacro/_1 ?name)]
          =value (with-scope ?name
                   (with-scoped-name ?name =function
                     (with-local ?tokens =tokens
                       (analyse-form* ?value))))
-         :let [_ (prn 'analyse-defmacro/_2 ?name)]
          =function (within :types (exec [_ (&type/solve =return (:type =value))]
                                     (&type/clean =function)))
-         :let [_ (prn 'analyse-defmacro/_3 ?name)]
          _ (define-fn ?name {:mode   ::macro
                              :access ::public
-                             :type   =function})
-         :let [_ (prn 'analyse-defmacro/_4 ?name)]]
+                             :type   =function})]
     (return (annotated [::def [?name (list ?tokens)] =value] ::&type/nothing))))
 
 (defanalyser analyse-lambda
diff --git a/src/lux/compiler.clj b/src/lux/compiler.clj
index 07a1df1a4..9f6a6cd6c 100644
--- a/src/lux/compiler.clj
+++ b/src/lux/compiler.clj
@@ -26,11 +26,8 @@
 
 ;; [Utils/General]
 (defn ^:private write-file [file data]
-  ;; (println 'write-file file (alength data))
   (with-open [stream (java.io.BufferedOutputStream. (java.io.FileOutputStream. file))]
-    (.write stream data))
-  ;; (Thread/sleep 2000)
-  )
+    (.write stream data)))
 
 (defn ^:private write-class [name data]
   (write-file (str "output/" name ".class") data))
@@ -47,7 +44,6 @@
            ~'*writer* (:writer ~'*state*)
            ~'*parent* (:parent ~'*state*)
            ~'*type* (:type (:form ~'*state*))]
-       ;; (prn '~name (:form (:form ~'*state*)))
        (match (:form (:form ~'*state*))
          ~match
          (do ~body
@@ -146,9 +142,7 @@
 
         (instance? java.lang.Boolean ?literal)
         (if ?literal
-          ;; (.visitLdcInsn *writer* (int 1))
           (.visitFieldInsn *writer* Opcodes/GETSTATIC (->class "java.lang.Boolean") "TRUE" (->type-signature "java.lang.Boolean"))
-          ;; (.visitLdcInsn *writer* (int 0))
           (.visitFieldInsn *writer* Opcodes/GETSTATIC (->class "java.lang.Boolean") "FALSE" (->type-signature "java.lang.Boolean")))
 
         (string? ?literal)
@@ -159,8 +153,7 @@
 
 (defcompiler ^:private compile-tuple
   [::&analyser/tuple ?elems]
-  (let [;; _ (prn 'compile-tuple (count ?elems))
-        num-elems (count ?elems)]
+  (let [num-elems (count ?elems)]
     (let [tuple-class (str (str +prefix+ "/Tuple") num-elems)]
       (doto *writer*
         (.visitTypeInsn Opcodes/NEW tuple-class)
@@ -173,112 +166,85 @@
 
 (defcompiler ^:private compile-local
   [::&analyser/local ?env ?idx]
-  (do ;; (prn 'LOCAL ?idx)
-      (doto *writer*
-        (.visitVarInsn Opcodes/ALOAD (int ?idx)))))
+  (doto *writer*
+    (.visitVarInsn Opcodes/ALOAD (int ?idx))))
 
 (defcompiler ^:private compile-captured
   [::&analyser/captured ?scope ?captured-id ?source]
-  (do ;; (prn 'CAPTURED [?scope ?captured-id])
-      (doto *writer*
-        (.visitVarInsn Opcodes/ALOAD 0)
-        (.visitFieldInsn Opcodes/GETFIELD
-                         (apply str (interpose "$" (map (comp normalize-ident str) ?scope)))
-                         (str "__" ?captured-id)
-                         "Ljava/lang/Object;"))))
+  (doto *writer*
+    (.visitVarInsn Opcodes/ALOAD 0)
+    (.visitFieldInsn Opcodes/GETFIELD
+                     (apply str (interpose "$" (map (comp normalize-ident str) ?scope)))
+                     (str "__" ?captured-id)
+                     "Ljava/lang/Object;")))
 
 (defcompiler ^:private compile-global
   [::&analyser/global ?owner-class ?name]
-  (do ;; (prn 'GLOBAL ?owner-class ?name *type*)
-      ;; (prn 'compile-global (->class (str ?owner-class "$" ?name)) "_datum")
-      (doto *writer*
-        (.visitFieldInsn Opcodes/GETSTATIC (->class (str ?owner-class "$" (normalize-ident ?name))) "_datum" "Ljava/lang/Object;" ;; (->java-sig *type*)
-                         ))))
+  (doto *writer*
+    (.visitFieldInsn Opcodes/GETSTATIC (->class (str ?owner-class "$" (normalize-ident ?name))) "_datum" "Ljava/lang/Object;")))
 
 (defcompiler ^:private compile-global-fn
   [::&analyser/global-fn ?owner-class ?name]
   (let [fn-class (str ?owner-class "$" (normalize-ident ?name))]
     (.visitFieldInsn *writer* Opcodes/GETSTATIC (->class fn-class) "_datum" (->type-signature fn-class))))
 
-;; (defcompiler ^:private compile-call
-;;   [::&analyser/call ?fn ?args]
-;;   (do (prn 'compile-call (:form ?fn) ?fn ?args)
-;;     (doseq [arg (reverse ?args)]
-;;       (compile-form (assoc *state* :form arg)))
-;;     (match (:form ?fn)
-;;       [::&analyser/global ?owner-class ?fn-name]
-;;       (let [signature (str "(" (apply str (repeat (count ?args) "Ljava/lang/Object;")) ")" "Ljava/lang/Object;")]
-;;         (doto *writer*
-;;           (.visitMethodInsn Opcodes/INVOKESTATIC (->class ?owner-class) ?fn-name signature))))))
-
 (defcompiler ^:private compile-call
   [::&analyser/call ?fn ?args]
-  (do ;; (prn 'compile-call (:form ?fn) ?fn ?args)
-      (do (compile-form (assoc *state* :form ?fn))
-        (let [apply-signature "(Ljava/lang/Object;)Ljava/lang/Object;"]
-          (doseq [arg ?args]
-            (compile-form (assoc *state* :form arg))
-            (.visitMethodInsn *writer* Opcodes/INVOKEINTERFACE (str +prefix+ "/Function") "apply" apply-signature))))))
+  (do (compile-form (assoc *state* :form ?fn))
+    (let [apply-signature "(Ljava/lang/Object;)Ljava/lang/Object;"]
+      (doseq [arg ?args]
+        (compile-form (assoc *state* :form arg))
+        (.visitMethodInsn *writer* Opcodes/INVOKEINTERFACE (str +prefix+ "/Function") "apply" apply-signature)))))
 
 (defcompiler ^:private compile-static-call
   [::&analyser/static-call ?needs-num ?fn ?args]
-  (do ;; (prn 'compile-call (:form ?fn) ?fn ?args)
-      (match (:form ?fn)
-        [::&analyser/global-fn ?owner-class ?fn-name]
-        (let [arg-sig (->type-signature "java.lang.Object")
-              call-class (str (->class ?owner-class) "$" (normalize-ident ?fn-name))
-              provides-num (count ?args)]
-          (if (>= provides-num ?needs-num)
-            (let [apply-signature "(Ljava/lang/Object;)Ljava/lang/Object;"
-                  impl-sig (str "(" (reduce str "" (repeat ?needs-num arg-sig)) ")" arg-sig)]
-              (doto *writer*
-                (-> (do (compile-form (assoc *state* :form arg)))
-                    (->> (doseq [arg (take ?needs-num ?args)])))
-                (.visitMethodInsn Opcodes/INVOKESTATIC call-class "impl" impl-sig)
-                (-> (doto (do (compile-form (assoc *state* :form arg)))
-                      (.visitMethodInsn Opcodes/INVOKEINTERFACE (str +prefix+ "/Function") "apply" apply-signature))
-                    (->> (doseq [arg (drop ?needs-num ?args)])))))
-            (let [counter-sig "I"
-                  init-signature (str "(" (apply str counter-sig (repeat (dec ?needs-num) arg-sig)) ")" "V")]
-              (doto *writer*
-                (.visitTypeInsn Opcodes/NEW call-class)
-                (.visitInsn Opcodes/DUP)
-                (.visitLdcInsn (int provides-num))
-                (-> (do (compile-form (assoc *state* :form arg)))
-                    (->> (doseq [arg ?args])))
-                (-> (.visitInsn Opcodes/ACONST_NULL)
-                    (->> (dotimes [_ (dec (- ?needs-num provides-num))])))
-                (.visitMethodInsn Opcodes/INVOKESPECIAL call-class "<init>" init-signature)))
-            ))
-        )))
+  (match (:form ?fn)
+    [::&analyser/global-fn ?owner-class ?fn-name]
+    (let [arg-sig (->type-signature "java.lang.Object")
+          call-class (str (->class ?owner-class) "$" (normalize-ident ?fn-name))
+          provides-num (count ?args)]
+      (if (>= provides-num ?needs-num)
+        (let [apply-signature "(Ljava/lang/Object;)Ljava/lang/Object;"
+              impl-sig (str "(" (reduce str "" (repeat ?needs-num arg-sig)) ")" arg-sig)]
+          (doto *writer*
+            (-> (do (compile-form (assoc *state* :form arg)))
+                (->> (doseq [arg (take ?needs-num ?args)])))
+            (.visitMethodInsn Opcodes/INVOKESTATIC call-class "impl" impl-sig)
+            (-> (doto (do (compile-form (assoc *state* :form arg)))
+                  (.visitMethodInsn Opcodes/INVOKEINTERFACE (str +prefix+ "/Function") "apply" apply-signature))
+                (->> (doseq [arg (drop ?needs-num ?args)])))))
+        (let [counter-sig "I"
+              init-signature (str "(" (apply str counter-sig (repeat (dec ?needs-num) arg-sig)) ")" "V")]
+          (doto *writer*
+            (.visitTypeInsn Opcodes/NEW call-class)
+            (.visitInsn Opcodes/DUP)
+            (.visitLdcInsn (int provides-num))
+            (-> (do (compile-form (assoc *state* :form arg)))
+                (->> (doseq [arg ?args])))
+            (-> (.visitInsn Opcodes/ACONST_NULL)
+                (->> (dotimes [_ (dec (- ?needs-num provides-num))])))
+            (.visitMethodInsn Opcodes/INVOKESPECIAL call-class "<init>" init-signature)))
+        ))
+    ))
 
 (defcompiler ^:private compile-jvm-getstatic
   [::&analyser/jvm-getstatic ?owner ?field]
-  (do ;; (prn 'compile-static-field ?owner ?field)
-      ;; (assert false)
-      (doto *writer*
-        (.visitFieldInsn Opcodes/GETSTATIC (->class ?owner) ?field (->java-sig *type*)))
-    ))
+  (doto *writer*
+    (.visitFieldInsn Opcodes/GETSTATIC (->class ?owner) ?field (->java-sig *type*))))
 
 (defcompiler ^:private compile-dynamic-field
   [::&analyser/dynamic-field ?target ?owner ?field]
-  (do ;; (prn 'compile-static-field ?owner ?field)
-      ;; (assert false)
-      (compile-form (assoc *state* :form ?target))
+  (do (compile-form (assoc *state* :form ?target))
     (doto *writer*
-      (.visitFieldInsn Opcodes/GETFIELD (->class ?owner) ?field (->java-sig *type*)))
-    ))
+      (.visitFieldInsn Opcodes/GETFIELD (->class ?owner) ?field (->java-sig *type*)))))
 
 (defcompiler ^:private compile-static-method
   [::&analyser/static-method ?owner ?method-name ?method-type ?args]
-  (do ;; (prn 'compile-dynamic-access ?target ?owner ?method-name ?method-type ?args)
-      ;; (assert false)
-      (do (doseq [arg ?args]
-            (compile-form (assoc *state* :form arg)))
-        (doto *writer*
-          (.visitMethodInsn Opcodes/INVOKESTATIC (->class ?owner) ?method-name (method->sig ?method-type))
-          (.visitInsn Opcodes/ACONST_NULL)))
-    ))
+  (do (doseq [arg ?args]
+        (compile-form (assoc *state* :form arg)))
+    (doto *writer*
+      (.visitMethodInsn Opcodes/INVOKESTATIC (->class ?owner) ?method-name (method->sig ?method-type))
+      (.visitInsn Opcodes/ACONST_NULL))))
 
 (defn prepare-arg! [*writer* class-name]
   (condp = class-name
@@ -339,8 +305,7 @@
 
 (defcompiler ^:private compile-jvm-invokevirtual
   [::&analyser/jvm-invokevirtual ?class ?method ?classes ?object ?args]
-  (let [;; _ (prn 'compile-jvm-invokevirtual [?class ?method ?classes] '-> *type*)
-        method-sig (str "(" (reduce str "" (map ->type-signature ?classes)) ")" (->java-sig *type*))]
+  (let [method-sig (str "(" (reduce str "" (map ->type-signature ?classes)) ")" (->java-sig *type*))]
     (compile-form (assoc *state* :form ?object))
     (.visitTypeInsn *writer* Opcodes/CHECKCAST (->class ?class))
     (doseq [[class-name arg] (map vector ?classes ?args)]
@@ -391,20 +356,16 @@
     [::&analyser/if ?test ?then ?else]
     (let [else-label (new Label)
           end-label (new Label)]
-      ;; (println "PRE")
       (compile-form (assoc *state* :form ?test))
       (doto *writer*
         (.visitTypeInsn Opcodes/CHECKCAST +bool-class+)
         (.visitMethodInsn Opcodes/INVOKEVIRTUAL +bool-class+ "booleanValue" "()Z")
         (.visitJumpInsn Opcodes/IFEQ else-label))
-      ;; (prn 'compile-if/?then (:form ?then))
       (compile-form (assoc *state* :form ?then))
-      ;; (.visitInsn *writer* Opcodes/POP)
       (doto *writer*
         (.visitJumpInsn Opcodes/GOTO end-label)
         (.visitLabel else-label))
       (compile-form (assoc *state* :form ?else))
-      ;; (.visitInsn *writer* Opcodes/POP)
       (.visitLabel *writer* end-label))))
 
 (defcompiler ^:private compile-do
@@ -421,7 +382,6 @@
       +variant-field-sig+ (->type-signature "java.lang.Object")
       equals-sig (str "(" (->type-signature "java.lang.Object") ")Z")]
   (defn compile-decision-tree [writer mappings default-label decision-tree]
-    ;; (prn 'compile-decision-tree decision-tree)
     (match decision-tree
       [::test-char ?pairs]
       (do (doseq [[?token $body] ?pairs
@@ -506,9 +466,7 @@
               (.visitJumpInsn Opcodes/IFEQ tag-else-label) ;; variant, tag
               (.visitInsn Opcodes/POP) ;; variant
               (do (let [arity (-> ?subcases first (nth 2) count)
-                        variant-class** (str variant-class* arity)
-                        ;; _ (prn ?tag arity variant-class**)
-                        ]
+                        variant-class** (str variant-class* arity)]
                     (.visitTypeInsn writer Opcodes/CHECKCAST variant-class**) ;; variantN
                     (doseq [subcase ?subcases
                             :let [next-subcase (new Label)]]
@@ -532,7 +490,6 @@
               ;; variant, tag ->
               (.visitLabel tag-else-label))
             (->> (doseq [[?tag ?subcases] ?cases
-                         ;; :let [_ (.print System/out (prn-str 'COMPILE-PATTERN ?tag ?subcases))]
                          :let [tag-else-label (new Label)]])))
         ;; variant, tag ->
         (.visitInsn Opcodes/POP) ;; variant ->
@@ -541,23 +498,18 @@
     ))
 
 (defn sequence-parts [branches parts]
-  ;; (.print System/out (prn-str 'sequence-parts branches parts))
   (if (empty? parts)
     '(())
     (let [[head & tail] parts
           expanded (case (:type head)
                      ::&analyser/defaults
                      (for [[?local ?supports] (:stores head)
-                           ?body (set/intersection branches ?supports)
-                           ;; :when (set/subset? branches ?supports)
-                           ]
+                           ?body (set/intersection branches ?supports)]
                        [[::store ?local ?body] #{?body}])
 
                      ::&analyser/char-tests
                      (concat (list [[::test-char (for [[?token ?supports] (:patterns head)
-                                                       ?body (set/intersection branches ?supports)
-                                                       ;; :when (set/subset? branches ?supports)
-                                                       ]
+                                                       ?body (set/intersection branches ?supports)]
                                                    [?token ?body])]
                                     branches])
                              (for [[_ ?local ?body] (:defaults head)
@@ -566,9 +518,7 @@
 
                      ::&analyser/text-tests
                      (concat (list [[::test-text (for [[?token ?supports] (:patterns head)
-                                                       ?body (set/intersection branches ?supports)
-                                                       ;; :when (set/subset? branches ?supports)
-                                                       ]
+                                                       ?body (set/intersection branches ?supports)]
                                                    [?token ?body])]
                                     branches])
                              (for [[_ ?local ?body] (:defaults head)
@@ -577,14 +527,11 @@
 
                      ::&analyser/tuple*
                      (concat (let [patterns (into {} (for [[?tag ?struct] (:patterns head)
-                                                           ;; :let [_ (.print System/out (prn-str 'PATTERN ?tag ?struct))]
                                                            :let [?parts (:parts ?struct)
                                                                  num-parts (count ?parts)
                                                                  ?supports (:branches ?struct)
                                                                  subcases (for [?body (set/intersection branches ?supports)
                                                                                 subseq (sequence-parts #{?body} ?parts)
-                                                                                ;; :let [_ (when (= "Symbol" ?tag)
-                                                                                ;;           (.print System/out (prn-str 'counting ?tag num-parts (count subseq) subseq)))]
                                                                                 :when (= num-parts (count subseq))]
                                                                             [::subcase ?body subseq])]
                                                            :when (not (empty? subcases))]
@@ -599,52 +546,27 @@
                                '()))
 
                      ::&analyser/adt*
-                     (do ;; (prn '(:default head) (:default head))
-                         ;; (assert (nil? (:default head)))
-                         ;; (let [patterns (into {} (for [[?tag ?struct] (:patterns head)
-                         ;;                               ;; :let [_ (.print System/out (prn-str 'PATTERN ?tag ?struct))]
-                         ;;                               :let [?parts (:parts ?struct)
-                         ;;                                     num-parts (count ?parts)
-                         ;;                                     ?supports (:branches ?struct)
-                         ;;                                     subcases (for [?body (set/intersection branches ?supports)
-                         ;;                                                    subseq (sequence-parts #{?body} ?parts)
-                         ;;                                                    ;; :let [_ (when (= "Symbol" ?tag)
-                         ;;                                                    ;;           (.print System/out (prn-str 'counting ?tag num-parts (count subseq) subseq)))]
-                         ;;                                                    :when (= num-parts (count subseq))]
-                         ;;                                                [::subcase ?body subseq])]
-                         ;;                               :when (not (empty? subcases))]
-                         ;;                           [?tag subcases]))]
-                         ;;   (if (empty? patterns)
-                         ;;     '()
-                         ;;     (list [[::test-adt branches patterns]
-                         ;;            branches])))
-                         (concat (let [patterns (into {} (for [[?tag ?struct] (:patterns head)
-                                                               ;; :let [_ (.print System/out (prn-str 'PATTERN ?tag ?struct))]
-                                                               :let [?parts (:parts ?struct)
-                                                                     num-parts (count ?parts)
-                                                                     ?supports (:branches ?struct)
-                                                                     subcases (for [?body (set/intersection branches ?supports)
-                                                                                    subseq (sequence-parts #{?body} ?parts)
-                                                                                    ;; :let [_ (when (= "Symbol" ?tag)
-                                                                                    ;;           (.print System/out (prn-str 'counting ?tag num-parts (count subseq) subseq)))]
-                                                                                    :when (= num-parts (count subseq))]
-                                                                                [::subcase ?body subseq])]
-                                                               :when (not (empty? subcases))]
-                                                           [?tag subcases]))]
-                                   (if (empty? patterns)
-                                     '()
-                                     (list [[::test-adt branches patterns]
-                                            branches])))
-                                 (if-let [[_ ?local ?body] (:default head)]
-                                   (for [?body (set/intersection branches #{?body})]
-                                     [[::default ?local ?body] #{?body}])
-                                   '()))
-                       )
+                     (concat (let [patterns (into {} (for [[?tag ?struct] (:patterns head)
+                                                           :let [?parts (:parts ?struct)
+                                                                 num-parts (count ?parts)
+                                                                 ?supports (:branches ?struct)
+                                                                 subcases (for [?body (set/intersection branches ?supports)
+                                                                                subseq (sequence-parts #{?body} ?parts)
+                                                                                :when (= num-parts (count subseq))]
+                                                                            [::subcase ?body subseq])]
+                                                           :when (not (empty? subcases))]
+                                                       [?tag subcases]))]
+                               (if (empty? patterns)
+                                 '()
+                                 (list [[::test-adt branches patterns]
+                                        branches])))
+                             (if-let [[_ ?local ?body] (:default head)]
+                               (for [?body (set/intersection branches #{?body})]
+                                 [[::default ?local ?body] #{?body}])
+                               '()))
                      )]
       (for [[step branches*] expanded
-            tail* (sequence-parts branches* tail)
-            ;; :let [_ (.print System/out (prn-str 'tail* tail*))]
-            ]
+            tail* (sequence-parts branches* tail)]
         (cons step tail*)))))
 
 (def !case-vars (atom -1))
@@ -653,83 +575,53 @@
       equals-sig (str "(" (->type-signature "java.lang.Object") ")Z")
       ex-class (->class "java.lang.IllegalStateException")]
   (defcompiler ^:private compile-case
-    ;; [::&analyser/case ?variant ?branches]
     [::&analyser/case ?base-idx ?variant ?max-registers ?branch-mappings ?decision-tree]
-    (do ;; (prn 'compile-case ?base-idx ?variant ?max-registers ?branch-mappings ?decision-tree)
-        ;; (assert false)
-        ;; (prn 'compile-case ?decision-tree)
-        (let [start-label (new Label)
-              end-label (new Label)
-              ;; default-label (new Label)
-              entries (for [[?branch ?body] ?branch-mappings
-                            :let [label (new Label)]]
-                        [[?branch label]
-                         [label ?body]])
-              mappings* (into {} (map first entries))]
-          (dotimes [idx ?max-registers]
-            (.visitLocalVariable *writer* (str "__" (swap! !case-vars inc) "__") (->java-sig ::&type/any) nil start-label end-label (+ ?base-idx (inc idx))))
-          (compile-form (assoc *state* :form ?variant))
+    (let [start-label (new Label)
+          end-label (new Label)
+          entries (for [[?branch ?body] ?branch-mappings
+                        :let [label (new Label)]]
+                    [[?branch label]
+                     [label ?body]])
+          mappings* (into {} (map first entries))]
+      (dotimes [idx ?max-registers]
+        (.visitLocalVariable *writer* (str "__" (swap! !case-vars inc) "__") (->java-sig ::&type/any) nil start-label end-label (+ ?base-idx (inc idx))))
+      (compile-form (assoc *state* :form ?variant))
+      (doto *writer*
+        (.visitInsn Opcodes/DUP)
+        (.visitLabel start-label))
+      (let [default-label (new Label)]
+        (doseq [decision-tree (let [pieces (map first (sequence-parts (:branches ?decision-tree) (list ?decision-tree)))]
+                                (if (or (:default ?decision-tree)
+                                        (not (empty? (:defaults ?decision-tree))))
+                                  (butlast pieces)
+                                  pieces))]
+          (compile-decision-tree *writer* mappings* default-label decision-tree))
+        (.visitLabel *writer* default-label)
+        (if-let [[_ [_ _ ?idx] ?body] (or (:default ?decision-tree)
+                                          (first (:defaults ?decision-tree)))]
           (doto *writer*
             (.visitInsn Opcodes/DUP)
-            (.visitLabel start-label))
-          (let [default-label (new Label)
-                ;; default-code (:default ?decision-tree)
-                ]
-            ;; (prn 'sequence-parts
-            ;;      (sequence-parts (:branches ?decision-tree) (list ?decision-tree)))
-            (doseq [decision-tree (let [pieces (map first (sequence-parts (:branches ?decision-tree) (list ?decision-tree)))]
-                                    (if (or (:default ?decision-tree)
-                                            (not (empty? (:defaults ?decision-tree))))
-                                      (butlast pieces)
-                                      pieces))]
-              (compile-decision-tree *writer* mappings* default-label decision-tree))
-            (.visitLabel *writer* default-label)
-            (if-let [[_ [_ _ ?idx] ?body] (or (:default ?decision-tree)
-                                              (first (:defaults ?decision-tree)))]
-              (doto *writer*
-                (.visitInsn Opcodes/DUP)
-                (.visitVarInsn Opcodes/ASTORE ?idx)
-                (.visitJumpInsn Opcodes/GOTO (get mappings* ?body)))
-              (doto *writer*
-                (.visitInsn Opcodes/POP)
-                ;; (.visitTypeInsn Opcodes/CHECKCAST (->class +variant-class+))
-                ;; (.visitFieldInsn Opcodes/GETFIELD (->class +variant-class+) "tag" (->type-signature "java.lang.String"))
-                (.visitTypeInsn Opcodes/NEW ex-class)
-                (.visitInsn Opcodes/DUP)
-                ;; (.visitInsn Opcodes/DUP_X1)
-                ;; (.visitInsn Opcodes/SWAP)
-                (.visitMethodInsn Opcodes/INVOKESPECIAL ex-class "<init>" "()V")
-                ;; (.visitMethodInsn Opcodes/INVOKESPECIAL ex-class "<init>" (str "(" (->type-signature "java.lang.String") ")" "V"))
-                (.visitInsn Opcodes/ATHROW)))
-            ;; (if default-code
-            ;;   ;; (do (prn 'default-code default-code)
-            ;;   ;;   (assert false)
-            ;;   ;;   ;; (.visitInsn Opcodes/POP) ;; ...
-            ;;   ;;   (compile-form (assoc *state* :form default-code))
-            ;;   ;;   (.visitJumpInsn *writer* Opcodes/GOTO end-label))
-            ;;   (doto *writer*
-            ;;     (.visitInsn Opcodes/POP)
-            ;;     (.visitTypeInsn Opcodes/NEW ex-class)
-            ;;     (.visitInsn Opcodes/DUP)
-            ;;     (.visitMethodInsn Opcodes/INVOKESPECIAL ex-class "<init>" "()V")
-            ;;     (.visitInsn Opcodes/ATHROW)))
-            )
-          ;; (compile-decision-tree *state* *writer* mappings* 1 nil (:branches ?decision-tree) ?decision-tree)
-          (doseq [[?label ?body] (map second entries)]
-            (.visitLabel *writer* ?label)
-            (.visitInsn *writer* Opcodes/POP)
-            (compile-form (assoc *state* :form ?body))
-            (.visitJumpInsn *writer* Opcodes/GOTO end-label))
-          (.visitLabel *writer* end-label)
-          ))
-    ))
+            (.visitVarInsn Opcodes/ASTORE ?idx)
+            (.visitJumpInsn Opcodes/GOTO (get mappings* ?body)))
+          (doto *writer*
+            (.visitInsn Opcodes/POP)
+            (.visitTypeInsn Opcodes/NEW ex-class)
+            (.visitInsn Opcodes/DUP)
+            (.visitMethodInsn Opcodes/INVOKESPECIAL ex-class "<init>" "()V")
+            (.visitInsn Opcodes/ATHROW))))
+      (doseq [[?label ?body] (map second entries)]
+        (.visitLabel *writer* ?label)
+        (.visitInsn *writer* Opcodes/POP)
+        (compile-form (assoc *state* :form ?body))
+        (.visitJumpInsn *writer* Opcodes/GOTO end-label))
+      (.visitLabel *writer* end-label)
+      )))
 
 (defcompiler ^:private compile-let
   [::&analyser/let ?idx ?label ?value ?body]
   (let [start-label (new Label)
         end-label (new Label)
         ?idx (int ?idx)]
-    ;; (prn '(:type ?value) (:type ?value) (->java-sig (:type ?value)))
     (.visitLocalVariable *writer* (normalize-ident ?label) (->java-sig (:type ?value)) nil start-label end-label ?idx)
     (assert (compile-form (assoc *state* :form ?value)) "CAN't COMPILE LET-VALUE")
     (doto *writer*
@@ -817,11 +709,8 @@
                                   (-> (.visitInsn Opcodes/ACONST_NULL)
                                       (->> (dotimes [clo_idx (- (dec num-captured) current-captured)])))
                                   (.visitMethodInsn Opcodes/INVOKESPECIAL current-class "<init>" init-signature)
-                                  ;; (.visitJumpInsn Opcodes/GOTO end-label)
                                   (.visitInsn Opcodes/ARETURN))
-                                (->> (doseq [[branch-label current-captured] (map vector branch-labels (range (count branch-labels)))
-                                             ;; :let [_ (prn '[branch-label current-captured] [branch-label current-captured])]
-                                             ])))
+                                (->> (doseq [[branch-label current-captured] (map vector branch-labels (range (count branch-labels)))])))
                             (.visitLabel default-label)
                             (-> (doto (.visitVarInsn Opcodes/ALOAD 0)
                                   (.visitFieldInsn Opcodes/GETFIELD current-class (str "_" clo_idx) clo-field-sig))
@@ -829,7 +718,6 @@
                           (->> (when (not= 0 num-captured))))
                       (.visitVarInsn Opcodes/ALOAD 1)
                       (.visitMethodInsn Opcodes/INVOKESTATIC current-class "impl" real-signature)
-                      ;; (.visitLabel end-label)
                       (.visitInsn Opcodes/ARETURN)
                       (.visitMaxs 0 0)
                       (.visitEnd)))
@@ -864,25 +752,22 @@
 
 (defcompiler ^:private compile-def
   [::&analyser/def ?form ?body]
-  (do ;; (prn 'compile-def ?form)
-      (match ?form
-        (?name :guard string?)
-        (compile-field *writer* *class-name* ?name ?body *state*)
-
-        [?name ?args]
-        (do ;; (prn 'compile-def `(~'def (~(symbol ?name) ~@(map symbol ?args))))
-            (if (= "main" ?name)
-              (let [signature "([Ljava/lang/String;)V"
-                    =method (doto (.visitMethod *writer* (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) ?name signature nil nil)
-                              (.visitCode))]
-                ;; (prn 'FN/?body ?body)
-                (compile-form (assoc *state* :parent *writer* :writer =method :form ?body))
-                (doto =method
-                  (.visitInsn Opcodes/RETURN)
-                  (.visitMaxs 0 0)
-                  (.visitEnd)))
-              (compile-method-function *writer* *class-name* ?name (count ?args) ?body *state*)))
-        )))
+  (match ?form
+    (?name :guard string?)
+    (compile-field *writer* *class-name* ?name ?body *state*)
+
+    [?name ?args]
+    (if (= "main" ?name)
+      (let [signature "([Ljava/lang/String;)V"
+            =method (doto (.visitMethod *writer* (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) ?name signature nil nil)
+                      (.visitCode))]
+        (compile-form (assoc *state* :parent *writer* :writer =method :form ?body))
+        (doto =method
+          (.visitInsn Opcodes/RETURN)
+          (.visitMaxs 0 0)
+          (.visitEnd)))
+      (compile-method-function *writer* *class-name* ?name (count ?args) ?body *state*))
+    ))
 
 (defn ^:private captured? [form]
   (match form
@@ -893,14 +778,11 @@
 
 (defcompiler ^:private compile-lambda
   [::&analyser/lambda ?scope ?frame ?args ?body]
-  (let [;; _ (prn '[?scope ?frame] ?scope ?frame ?args)
-        num-args (count ?args)
-        ;; outer-class (->class *class-name*)
+  (let [num-args (count ?args)
         clo-field-sig (->type-signature "java.lang.Object")
         counter-sig "I"
         apply-signature "(Ljava/lang/Object;)Ljava/lang/Object;"
         real-signature (str "(" (apply str (repeat num-args clo-field-sig)) ")" "Ljava/lang/Object;")
-        ;; current-class (apply str (interpose "$" ?scope))
         current-class (apply str (interpose "$" (map (comp normalize-ident str) ?scope)))
         num-captured (dec num-args)
         init-signature (str "(" (apply str (repeat (->> (:mappings ?frame)
@@ -912,8 +794,6 @@
                               (apply str counter-sig (repeat num-captured clo-field-sig)))
                             ")"
                             "V")
-        ;; _ (prn current-class 'init-signature init-signature)
-        ;; _ (prn current-class 'real-signature real-signature)
         =class (doto (new ClassWriter ClassWriter/COMPUTE_MAXS)
                  (.visit Opcodes/V1_5 (+ Opcodes/ACC_PUBLIC Opcodes/ACC_FINAL Opcodes/ACC_SUPER)
                          current-class nil "java/lang/Object" (into-array [(str +prefix+ "/Function")]))
@@ -981,9 +861,7 @@
                                     (->> (dotimes [clo_idx (- (dec num-captured) current-captured)])))
                                 (.visitMethodInsn Opcodes/INVOKESPECIAL current-class "<init>" init-signature)
                                 (.visitInsn Opcodes/ARETURN))
-                              (->> (doseq [[branch-label current-captured] (map vector branch-labels (range (count branch-labels)))
-                                           ;; :let [_ (prn '[branch-label current-captured] [branch-label current-captured])]
-                                           ])))
+                              (->> (doseq [[branch-label current-captured] (map vector branch-labels (range (count branch-labels)))])))
                           (.visitLabel default-label)
                           (-> (doto (.visitVarInsn Opcodes/ALOAD 0)
                                 (.visitFieldInsn Opcodes/GETFIELD current-class (str "_" clo_idx) clo-field-sig))
@@ -994,7 +872,6 @@
                     (.visitInsn Opcodes/ARETURN)
                     (.visitMaxs 0 0)
                     (.visitEnd)))
-        ;; _ (prn 'LAMBDA/?body ?body)
         =impl (doto (.visitMethod =class Opcodes/ACC_PUBLIC "impl" real-signature nil nil)
                 (.visitCode)
                 (->> (assoc *state* :form ?body :writer)
@@ -1006,17 +883,6 @@
         bytecode (.toByteArray =class)]
     (write-class current-class bytecode)
     (load-class! (string/replace current-class #"/" ".") (str current-class ".class"))
-    ;; (apply prn 'LAMBDA ?scope ?args (->> (:mappings ?frame)
-    ;;                                      (map second)
-    ;;                                      (map :form)
-    ;;                                      (filter captured?)))
-    ;; (prn 'M2 (:mappings ?frame))
-    ;; (prn 'M2 (->> (:mappings ?frame)
-    ;;               (filter (comp captured? :form second))))
-    ;; (prn 'M3 (->> (:mappings ?frame)
-    ;;               (filter (comp captured? :form second))
-    ;;               (sort #(< (-> %1 second :form (nth 2))
-    ;;                         (-> %2 second :form (nth 2))))))
     (doto *writer*
       (.visitTypeInsn Opcodes/NEW current-class)
       (.visitInsn Opcodes/DUP)
@@ -1028,7 +894,6 @@
                                               (sort #(< (-> %1 second :form (nth 2))
                                                         (-> %2 second :form (nth 2)))))])))
       (-> (doto (.visitInsn Opcodes/ICONST_0)
-            ;; (.visitInsn Opcodes/ICONST_0)
             (-> (.visitInsn Opcodes/ACONST_NULL)
                 (->> (doseq [_ (butlast ?args)]))))
           (->> (when (> (count ?args) 1))))
@@ -1076,7 +941,6 @@
 (defcompiler ^:private compile-variant
   [::&analyser/variant ?tag ?members]
   (let [variant-class* (str (->class +variant-class+) (count ?members))]
-    ;; (prn 'compile-variant ?tag ?value)
     (doto *writer*
       (.visitTypeInsn Opcodes/NEW variant-class*)
       (.visitInsn Opcodes/DUP)
@@ -1097,18 +961,10 @@
 (defcompiler compile-use
   [::&analyser/use ?file ?alias]
   (let [module-name (re-find #"[^/]+$" ?file)
-        ;; _ (prn 'module-name module-name)
         source-code (slurp (str "source/" module-name ".lux"))
-        ;; _ (prn 'source-code source-code)
         tokens (&lexer/lex source-code)
-        ;; _ (prn 'tokens tokens)
         syntax (&parser/parse tokens)
-        ;; _ (prn 'syntax syntax)
-        ;; ann-syntax (&analyser/analyse module-name syntax)
-        ;; _ (prn 'ann-syntax ann-syntax)
         bytecode (compile module-name syntax)]
-    ;; (write-file (str module-name ".class") bytecode)
-    ;; (load-class! (string/replace module-name #"/" ".") (str module-name ".class"))
     nil))
 
 (let [+int-class+ (->class "java.lang.Integer")]
@@ -1166,22 +1022,13 @@
                    compile-jvm-aastore
                    compile-jvm-aaload]]
   (defn ^:private compile-form [state]
-    ;; (prn 'compile-form/state state)
     (or (some #(% state) +compilers+)
         (assert false (str "Can't compile: " (pr-str (:form state)))))))
 
 ;; [Interface]
 (def !state (atom nil))
 
-;; "map" {:mode :lux.analyser/function,
-;;        :access :lux.analyser/public,
-;;        :type [:lux.type/function (:lux.type/any :lux.type/any) :lux.type/any]}
-
-;; "map" {:form [:lux.analyser/global-fn "lux" "map"],
-;;        :type [:lux.type/function (:lux.type/any :lux.type/any) :lux.type/any]}
-
 (defn compile [module-name inputs]
-  ;; (prn 'inputs inputs)
   (if-let [module (get-in @!state [:modules module-name])]
     (assert false "Can't redefine a module!")
     (do (reset-loader!)
diff --git a/src/lux/lexer.clj b/src/lux/lexer.clj
index c0ced6baf..8f7bdbb1d 100644
--- a/src/lux/lexer.clj
+++ b/src/lux/lexer.clj
@@ -39,13 +39,8 @@
 
 (def ^:private lex-string-body
   (try-all-m [(exec [[prefix escaped] (lex-regex2 #"(?s)^([^\"\\]*)(\\.)")
-                     ;; :let [_ (prn '[prefix escaped] [prefix escaped])]
                      unescaped (escape-char escaped)
-                     ;; :let [_ (prn 'unescaped unescaped)]
-                     postfix lex-string-body
-                     ;; :let [_ (prn 'postfix postfix)]
-                     ;; :let [_ (prn 'FULL (str prefix unescaped postfix))]
-                     ]
+                     postfix lex-string-body]
                 (return (str prefix unescaped postfix)))
               (lex-regex #"(?s)^([^\"\\]*)")]))
 
@@ -74,41 +69,24 @@
 
 (def ^:private lex-text
   (exec [_ (lex-str "\"")
-         ;; state &util/get-state
-         ;; :let [_ (prn 'PRE state)]
          token lex-string-body
-         _ (lex-str "\"")
-         ;; state &util/get-state
-         ;; :let [_ (prn 'POST state)]
-         ]
+         _ (lex-str "\"")]
     (return [::text token])))
 
 (def ^:private lex-single-line-comment
   (exec [_ (lex-str "##")
          comment (lex-regex #"^([^\n]*)")
-         _ (lex-regex #"^(\n?)")
-         ;; :let [_ (prn 'comment comment)]
-         ]
+         _ (lex-regex #"^(\n?)")]
     (return [::comment comment])))
 
 (def ^:private lex-multi-line-comment
   (exec [_ (lex-str "#(")
-         ;; :let [_ (prn 'OPEN)]
-         ;; comment (lex-regex #"^(#\(.*\)#)")
          comment (try-all-m [(lex-regex #"(?is)^((?!#\().)*?(?=\)#)")
                              (exec [pre (lex-regex #"(?is)^(.+?(?=#\())")
-                                    ;; :let [_ (prn 'PRE pre)]
                                     [_ inner] lex-multi-line-comment
-                                    ;; :let [_ (prn 'INNER inner)]
-                                    post (lex-regex #"(?is)^(.+?(?=\)#))")
-                                        ;:let [_ (prn 'POST post)]
-                                    ]
+                                    post (lex-regex #"(?is)^(.+?(?=\)#))")]
                                (return (str pre "#(" inner ")#" post)))])
-         ;; :let [_ (prn 'COMMENT comment)]
-         _ (lex-str ")#")
-         ;; :let [_ (prn 'CLOSE)]
-         ;; :let [_ (prn 'multi-comment comment)]
-         ]
+         _ (lex-str ")#")]
     (return [::comment comment])))
 
 (def ^:private lex-comment
diff --git a/src/lux/parser.clj b/src/lux/parser.clj
index d25208dc5..bb7b0f212 100644
--- a/src/lux/parser.clj
+++ b/src/lux/parser.clj
@@ -60,22 +60,6 @@
                        ?elems)]
     (return [::form =elems])))
 
-;; (defparser ^:private parse-get
-;;   [::&lexer/list ([[::&lexer/ident "get@"] [::&lexer/tag ?tag] ?record] :seq)]
-;;   (exec [=record (apply-m parse-token (list ?record))]
-;;     (return [::get ?tag =record])))
-
-;; (defparser ^:private parse-remove
-;;   [::&lexer/list ([[::&lexer/ident "remove@"] [::&lexer/tag ?tag] ?record] :seq)]
-;;   (exec [=record (apply-m parse-token (list ?record))]
-;;     (return [::remove ?tag =record])))
-
-;; (defparser ^:private parse-set
-;;   [::&lexer/list ([[::&lexer/ident "set@"] [::&lexer/tag ?tag] ?value ?record] :seq)]
-;;   (exec [=value (apply-m parse-token (list ?value))
-;;          =record (apply-m parse-token (list ?record))]
-;;     (return [::set ?tag =value =record])))
-
 (def ^:private parse-token
   (try-all-m [parse-bool
               parse-int