 
 
 (defprotocol Satisfiable
-  (satisfied? [x]))
+  (satisfied? [self y]))
 
 (defrecord Constraint
   [name description properties strict satisfy-fn]
   Satisfiable
-  (satisfied? [x]
-    (satisfy-fn x)))
+  (satisfied? [self y]
+    (satisfy-fn y)))
 
 (def field-constraints [(->Constraint
                           "aggregate-op-supported-by-type"

                                  has-y false]
                             (let [first-field (first curr-fields)
                                   rest-fields (rest curr-fields)]
                               (if (not (empty curr-fields))
                                 (cond
                                   (= (::sp/channel first-field) ::sp/x)
                                   (recur rest-fields

                                     rest-fields (rest curr-fields)]
                                 (if (not (empty curr-fields))
                                   (if (not (::sp/aggregate curr-fields))
                                     (if (or (= (::sp/channel first-field) ::sp/row)
                                             (= (::sp/channel first-field) ::sp/column))
                                       (recur rest-fields has-non-facet-dim true true)
                                       (recur rest-fields has-non-facet-dim true has-enumerated-facet-dim))
                                     (recur rest-fields true has-dim has-enumerated-facet-dim))
                                   (if (and has-dim (not has-non-facet-dim))
                                     (if has-enumerated-facet-dim
                                       false
                                       true)
                                     true))))
