    (cond
      (map? f) (apply-entries {}
                   (map (fn [[k v]]
-                         (assc-transitive k (transitive v)))
+                         (transitive-map k (transitive v)))
                     f))
      (seq? f) (apply-entries '()
-                    (map (comp lst-transitive transitive) f))
+                    (map (comp transitive-lst transitive) f))
      (vector? f) (apply-entries []
-                      (map (comp lst-transitive transitive) f))
+                      (map (comp transitive-lst transitive) f))
      (set? f) (apply-entries #{}
-                   (map (comp lst-transitive transitive) f))
+                   (map (comp transitive-lst transitive) f))
      (fn? f) f
      (keyword? f) f
      :else

  ([f m]
   (cond
     ;; map deepfmap over all the entries until it thunks out
     (list? m) (u/save-meta (reverse (flst f m)) m)
     (vector? m) (u/save-meta (fvec f m) m)
     (seq? m) (u/save-meta (fseq f m) m)
     (set? m) (u/save-meta (fset f m) m)
     ;; map deepfmap over all the vals (nested too)
     (associative? m) (u/save-meta (fassc f m) m)
     ;; two base cases here:
     ;; compose fns
     (fn? m) (comp f m)

   ;; same thing here but we'll mutually walk ms
   (let [mcoll (cons m ms)]
     (cond
       (list? m) (u/save-metas (map (partial fmap-lst f) mcoll) mcoll)
       (vector? m) (u/save-metas (map (partial fmap-vec f) mcoll) mcoll)
       (seq? m) (u/save-metas (map (partial fmap-seq f) mcoll) mcoll)
       (set? m) (u/save-metas (map (partial fmap-set f) mcoll) mcoll)
       (associative? m) (u/save-metas (fmap-map f m ms) mcoll)
       (fn? m) (map #(comp f %) mcoll)
       :else
       (apply f mcoll)))))
