                                              " instead of a map.")]})))
                          {:actual actual})))
         :else
-        (report {:type :mock-expected-result-failure
-                 :position (:position call)
-                 :binding-note (:binding-note call)
-                 :actual actual
-                 :expected (:expected-result call) })))
+        (report (success-result :mock-expected-result-failure actual call))))
 
 (defmethod check-result :check-negated-match [actual call]
    (cond (not (extended-= actual (:expected-result call)))
          (report {:type :pass})
 
-        (fn? (call :expected-result))
-        (report {:type :mock-actual-inappropriately-matches-checker
-                 :binding-note (:binding-note call)
-                 :position (:position call)
-                 :expected (:expected-result-text-for-failures call)
-                 :actual actual})
+        (fn? (:expected-result call))
+        (report (failure-result :mock-actual-inappropriately-matches-checker actual call))
 
         :else
-        (report {:type :mock-expected-result-inappropriately-matched
-                 :binding-note (:binding-note call)
-                 :position (:position call)
-                 :expected (:expected-result-text-for-failures call) 
-                 :actual actual})))
+        (report (failure-result :mock-expected-result-inappropriately-matched actual call))))
 
 (defn expect*
   "The core function in unprocessed Midje. Takes a map describing a

                                     ((:function-under-test unprocessed-check))))]
        (check-call-counts local-fakes)
        (check-result code-under-test-result unprocessed-check)
        :irrelevant-return-value))))

(immigrate 'midje.checkers)


(defmulti ^{:private true} check-result (fn [actual call] 
                                          (:desired-check call)))

(letfn [(base-result [type actual call] 
          {:type type
           :binding-note (:binding-note call)
           :position (:position call)
           :actual actual })]

  (defn- failure-result [type actual call]
    (assoc (base-result type actual call) :expected (:expected-result-text-for-failures call)))

  (defn- success-result [type actual call]
    (assoc (base-result type actual call) :expected (:expected-result call) )))

(defmethod check-result :check-match [actual call]
  (cond (extended-= actual (:expected-result call))
        (report {:type :pass})

        (fn? (:expected-result call))
        (report (merge (failure-result :mock-expected-result-functional-failure actual call)
                       (if (chatty-checker? (:expected-result call))
                         (do
                           (let [chatty-result ((:expected-result call) actual)]
