anchor.diff:  (defun post-matchmaker (id)
     (let* ((id (parse-integer id))
            (item (db id))
  -         (old-matches)
  -         (old-hidden-matches)
  +         (prior-matchmaker (or (getf item :match-all-terms)
  +                               (getf item :match-any-terms)))
            (by (getf item :by))
            (all-terms (post-parameter-words "match-all-terms"))
   
  
positive.code:                  (pushnew (cons request-id offer-id) it :test #'equal)))))
  
      (amodify-db request-id
                  :matching-offers new-useful-offers
                  :hidden-matching-offers (intersection rejected-offers
                                                        new-matching-offers))))
  
  (defun unmatch-offer-matches (offer-id offered-by requests-to-unmatch)
    (dolist (request-id requests-to-unmatch)
  
negative.code:          (distance (unless (equal raw-distance 0)
                       raw-distance))
           (base-url (strcat "/requests/" id))
           (hide-offer (post-parameter-integer "hide-offer"))
           (match-url (url-compose base-url "selected" "matchmaker")))
  
      (if hide-offer
        (progn
          (reject-matching-offer id hide-offer)
          (see-other (or (post-parameter "next") (referer) "/home")))
  
        (require-test ((or (eql *userid* by)
                           (group-admin-p by)
                           (matchmaker-admin-p))
                       (s+ "You can only edit your own matchmaker notifications."))
  
          (flet ((try-again (e)
                   (flash e :error t)
                   (get-request id
                                :notify-matches (or notify
                                                    (getf item :notify-matches))
                                :all-terms (or all-terms
                                               (getf item :match-all-terms))
                                :any-terms (or any-terms
                                               (getf item :match-any-terms))
                                :without-terms (or without-terms
                                                   (getf item :match-no-terms))
                                :distance (or distance (getf item :match-distance)))))
  
            (cond
              ((not (eql (getf item :type) :request))
               (flash "Matchmaker notifications are currently only available for requests" :error t)
               (see-other (referer)))
  
              ((not (and (getf *user* :lat) (getf *user* :long)))
                (try-again "You need to enter your location on your <a href=\"/settings\">settings page</a> before you can create or edit matchmaker notifications."))
  
              ((post-parameter "edit-original")
               (enter-inventory-tags :title "Edit your request"
                                     :action base-url
                                     :text (getf item :text)
                                     :tags (getf item :tags)
                                     :groups-selected (getf item :privacy)
                                     :restrictedp (getf item :privacy)
                                     :next match-url
                                     :existingp t
                                     :button-text "Save request"
                                     :selected "requests"))
  
              ((nor any-terms all-terms)
               ;; very important that all matchmakers have at least one of these.
               ;; indexing and searching depend on (or any-terms all-terms)
               (try-again "Please enter at least 1 search term you would like to be notified about"))
  
              (t
               (let ((new-matchmaker-data (modify-db id
                                                     :notify-matches notify
                                                     :match-all-terms all-terms
                                                     :match-any-terms any-terms
                                                     :match-no-terms without-terms
                                                     :match-distance distance)))
                 (if prior-matchmaker
                   (modify-matchmaker id new-matchmaker-data)
                   (progn
                     (with-mutex (*requests-without-matchmakers-mutex*)
                       (asetf *requests-without-matchmakers-index*
                              (remove id it :key #'result-id)))
                     (index-matchmaker id new-matchmaker-data))))
  
               (update-matchmaker-request-data id)
               (see-other (or (post-parameter "next")
                              (url-compose (strcat "/requests/" id)))))))))))
  
  (defun index-matchmaker (request-id &optional data)
    (flet ((stem-terms (terms)
  