            ~@(mapcat (fn [[multi-case schema]]
                        [multi-case (if-not (traceable-index? multi-case diff)
                                      value-2
-                                     (diff* schema value-1 value-2))])
+                                     (diff schema value-1 value-2))])
                      multi-cases))))))
 
-(defmethod diff* :custom [schema value-1 value-2]
+(defmethod diff :custom [schema value-1 value-2]
   `(~(runtime-processor schema *direction*) ~value-1 ~value-2 ~'config))
 
-(defmethod diff* :non-diffable [schema value-1 value-2]
+(defmethod diff :non-diffable [schema value-1 value-2]
   (decorate-common schema value-1 value-2 value-2))
 
 (defn make-common [schema config direction]
   (binding [*config*    config
             *direction* direction]
     `(fn [~'value-1 ~'value-2 ~'config]
-       ~(diff* schema 'value-1 'value-2))))
+       ~(diff schema 'value-1 'value-2))))
 
 (defn make-differ [schema config]
   (make-common schema config :differ))

                       inner-value-2
                       (let [inner-value-1 (gensym "inner-value-1_")]
                         `(let [~inner-value-1 (get ~value-1 ~index)]
                            ~(diff* inner-schema inner-value-1 inner-value-2)))))
                   disjoined-2))
         (decorate-common schema value-1 value-2))))

(defmethod diff* :record [schema value-1 value-2]
  (let [[_ {:keys [constructor diff]} :as schema] (expand-record schema (:schemas *config*))
        disjoined-2 (disj-indexed schema value-2)]
    (->> `(let [~@(mapcat (juxt :symbol :inner-value) disjoined-2)]

                                  inner-value-2
                                  (let [inner-value-1 (gensym "inner-value-1_")]
                                    `(let [~inner-value-1 (get ~value-1 ~index)]
                                       ~(diff inner-schema inner-value-1 inner-value-2))))]))
                  (into {})))
         (decorate-constructor constructor)
         (decorate-common schema value-1 value-2))))

(defmethod diff :optional [[_ _ inner-schema] value-1 value-2]
  `(if (and ~value-1 ~value-2)
     ~(diff inner-schema value-1 value-2)
     ~value-2))

(defmethod diff :multi [[_ {:keys [diff]} selector multi-cases] value-1 value-2]
  (let [selector-fn (gensym "selector-fn_")
        case-1      (gensym "case-1_")
        case-2      (gensym "case-2_")]
