   [ [binding-var] [function & arglist] ]
   (let [result-symbol (gensym "chatty-intermediate-results-")
         [complex-forms substituted-arglist] (chatty-untease result-symbol arglist)]
-    `(with-meta (fn [~binding-var]
-                  (let [~result-symbol (vector ~@complex-forms)]
-                    (if (~function ~@substituted-arglist)
-                      true
-                      (let [pairs# (map vector '~complex-forms ~result-symbol)]
-                        (tag-as-chatty-falsehood {:actual ~binding-var,
-                                                  :intermediate-results pairs#})))))
-       {:midje/chatty-checker true, :midje/checker true})))
+    `(tag-as-chatty-checker
+      (fn [~binding-var]
+        (let [~result-symbol (vector ~@complex-forms)]
+          (if (~function ~@substituted-arglist)
+            true
+            (let [pairs# (map vector '~complex-forms ~result-symbol)]
+              (tag-as-chatty-falsehood {:actual ~binding-var,
+                                        :intermediate-results pairs#}))))))))
 
  ;;Concerning Throwables

                   starting-candidate)))))

;; 

(defn compatibility-failure [actual expected kind]
  (cond (regex? expected)
	(and (not (sequential? actual))
	     (not (empty? kind))
	     (noted-falsehood (str "I don't know how to make sense of a "
				   "regular expression applied "
				   kind ".")))

	(not (collection-like? actual))
	(noted-falsehood (format "You can't compare %s (%s) to %s (%s)."
				 (pr-str actual) (type actual)
				 (pr-str expected) (type expected)))
	
	(and (map? actual)
	     (not (map? expected)))
	(try (into {} expected) nil
	     (catch Throwable ex
	       (format "If %s is a map, %s should look like map entries."
		       (pr-str actual) (pr-str expected))))))
  
(defn- standardized-arguments [actual expected kind]
  "Reduce arguments to standard forms so there are fewer combinations to
   consider."

  (cond (sequential? actual)
	(cond (set? expected)
	      [actual (vec expected) (union kind #{:in-any-order})]

                                 (cl-format nil " of size ~R." (count expected)))]}))))))

(def has-prefix
     (container-checker-maker 'has-prefix
      (has-xfix "prefix" #(re-pattern (str "^" (.toString %))) take)))
(def has-suffix
     (container-checker-maker 'has-suffix
      (has-xfix "suffix" #(re-pattern (str (.toString %) "$" )) take-last)))
                            
(defn has [quantifier predicate]
