 ;; Simple checkers
 
 (defn- named [name expected function]
+  "Adds a string name that looks like a function call to
+   a functions metadata under :name"
   (with-meta function
-	{:name (format "(%s %s)" name expected)}))
+        {:name (format "(%s %s)" name expected)}))
   
 
 (defn truthy 

(defn extended-= [actual expected]
  (try
    (cond (chatty-checker-falsehood? actual)
	  actual

	  (chatty-checker-falsehood? expected)
	  expected
	  
	  (extended-fn? expected)
          (let [function-result (expected actual)]
            (if (chatty-checker-falsehood? function-result) false function-result))
        
	  (regex? expected)
	  (if (regex? actual)
	    (= (.toString actual) (.toString expected))
	    (re-find expected actual))

	  :else
	  (= actual expected))
    (catch Exception ex false)))



      (cond (or (empty? walking-actual) (empty? walking-expected))
            (better-of candidate best-so-far)

            (extended-= (first walking-actual) (first walking-expected))
            ;; actual good so far, keep working on it
            (recur actual
                   (rest walking-actual)
                   (rest walking-expected)
                   best-so-far
                   (tack-on-to candidate
                               :actual-found (first walking-actual)
                               :expected-found (first walking-expected)))

            (and gaps-ok? (not (empty? (rest walking-actual))))
            ;; This is a gap in the walking actual. Skip it.
            (recur actual
                   (rest walking-actual)
                   walking-expected
                   best-so-far
                   candidate)

            (not (empty? actual))
            ;; See if we can find something better later on.
            (recur (rest actual)
                   (rest actual)
                   expected
                   (better-of candidate best-so-far)
                   starting-candidate)))))

;; 

(defn compatibility-check [actual expected kind]
  (cond (regex? expected)
	(cond (and (not (sequential? actual))
		   (not (empty? kind)))
