       (seq? form)
       (let [head (first form)]
         (cond
+          (= 'fn* head) {:form form}
           (util/macro? head) (apply xpand-macro head args)
           (= 'loop head) (apply xpand-loop args)
           (= 'recur head) (apply xpand-recur 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)

           :args args)))

(defn quote* [x] `'~x)

(defn recur-arity
  [v]
  (when (-> v meta ::util/recur)
    (count v)))

(def lazy-recur
  (concat '(recur)
          (for [x (range)]
            `(nth ~'$$return ~x))))

(defn mk-recur-handler
  [arity-set]
  `(case (recur-arity ~'$$return)
     ~@(apply concat
              (for [a arity-set]
                [a (take (inc a) lazy-recur)]))
     nil ~'$$return))

(defn prep-traced-bods
  [traced-bods]

                                               (:form xmap)
                                               (path->sym path))})))

(defn dot-sym?
  [sym]
  (-> sym
      str
      (.startsWith ".")))

(defn xpand-form
  [form src-map fn-meta path path-parent]
  (let [args [form src-map fn-meta path path-parent]]
