     (utils/map-of element satisfied? generality raw-query elements set-memberships)))
 
 (defn make-match-fn [meta arg-specs]
-  (fn [system common-feature-extractor args]
-    (assert (= (count args)
+  (fn [system args-memberships]
+    (assert (= (count args-memberships)
                (count arg-specs)))
-    (let [evaluated (map (fn [arg-spec arg]
-                           (evaluate-arg-match system common-feature-extractor arg-spec arg))
+    (let [evaluated (map (fn [arg-spec arg-memberships]
+                           (evaluate-arg-match system arg-spec arg-memberships))
                          arg-specs
-                         args)
+                         args-memberships)
           all-satisfied? (every? :satisfied? evaluated)
           generality (if all-satisfied?
                        (transduce (map :generality)

  (memoized-set-vectors-dominate? (alt-set-vector a)
                                  (alt-set-vector b)))

(defn resolve-fn-call [system dispatch-state args]
  (let [arity (count args)
        alternatives (map (fn [[k alt]]
                            (merge alt ((:match-fn alt)
                                        system
                                        (:feature-extractor dispatch-state)
                                        args)))
                          (get-in dispatch-state [:dispatch-map arity]))
        matching-alternatives (filter :satisfied? alternatives)
        frontier (pareto/elements (reduce pareto/insert

  {:classifier classifier
   :set-indicators (atom {})})

(defn evaluate-arg-match [system arg-spec set-memberships]
  (let [system (reduce ss/add system set-memberships)
        element (first set-memberships)

        _ (utils/data-assert (ss/element? system element)
