 
 (defn form->xform-map*
   [form]
-  (if (seq? form)
+  (if (coll? form)
     (let [x (macroexpand form)
           xx (clojure.walk/macroexpand-all form)] ;; TODO better way?
       (conj (mapcat form->xform-map* x)

         (:inner-path @tree-atom)
         tree-atom))

(defn mk-recent-tree-at-inner-path
  [inner-path recent-trees]
  (if (nil? inner-path)
    (let [new-tree (get-temp-root-tree)]
      (push-to-recent-trees!  new-tree
                              recent-trees)
      new-tree)
    (let [parent (produce-recent-parent-tree-atom! inner-path
                                                   recent-trees)
          new-tree (-> (trace/mk-tree :parent @parent)
                       (assoc :inner-path inner-path
                              :parent-path (:path @parent))
                       atom)]
      (push-to-recent-trees! new-tree

       (.startsWith ".")))

(defn xpand-form
  [form src-map fn-meta & [path path-chain]]
  (let [path' (or path [])
        path-chain' (or path-chain [])
        args [form src-map fn-meta path' path-chain']]
    (cond
      (seq? form)
      (let [head (first form)]
        (cond
          (= 'let head) (apply xpand-let args)

          (util/macro? head) (apply xpand-macro head args)

          (= 'if head) (apply xpand-if args)

          (or (special-symbol? head)
              (dot-sym? head)) ;; TODO better way to detect these?
          (apply xpand-all args)

          :else (apply xpand-fn head args)))

      (coll? form) (apply xpand-all args)
      :else form)))

;;TODO try-catch
