anchor.diff:    (let ((function-name
             (intern (string-downcase
                      (format nil +find-function-name-format-control+
  -                           'list from-end end
  +                           'list from-end (or end "nil")
  +                           ;; "nil" because otherwise
  +                           ;; format will exclude end= alltogether
                              (and test-suppliedp test)
                              (and test-not-suppliedp test-not)
                              key))))
  
positive.code: ;;; of find, we'll use a macro to create these functions.
  
  (defparameter +find-function-name-format-control+
    "find seq-type=~a from-end=~a end=~a ~
          ~@[test=~a~]~@[test-not=~a~] key=~a")
  
  (defmacro define-find-list-variant
  
negative.code: (define-find-list-variant :from-end true :end other :test-not other :key identity)
  (define-find-list-variant :from-end true :end other :test-not other :key other)
  
  (defmacro define-find-vector-variant
      (&key from-end
            (test     nil test-suppliedp)
            (test-not nil test-not-suppliedp)
            key)
    (let ((function-name
            (intern (string-downcase
                     (format nil +find-function-name-format-control+
                             'vector from-end nil
                             (and test-suppliedp test)
                             (and test-not-suppliedp test-not)
                             key))))
          (function-args `(item vector start end
                                ,@(if test-suppliedp
                                      (ecase test
                                        ((eq eql) nil)
                                        (other '(test))))
                                ,@(if test-not-suppliedp
                                      (ecase test-not
                                        ((eq eql) nil)
                                        (other '(test))))
                                ,@(ecase key
                                    (identity nil)
                                    (other '(key))))))
      `(defun ,function-name ,function-args
         (loop ,@(ecase from-end
                   (false '(for index from start below end))
                   (true '(for index downfrom (1- end) to start))) 
               when ,(let ((key-code
                             (ecase key
                               (identity '(aref vector index))
                               (other '(funcall key (aref vector index))))))
                       (cond
                         (test-suppliedp
                          (ecase test
                            ((eq eql) `(,test item ,key-code))
                            (other `(funcall test item ,key-code))))
                         (test-not-suppliedp
                          (ecase test-not
                            ((eq eql) `(not (,test-not item ,key-code)))
                            (other `(not (funcall test item ,key-code)))))
                         (t (error "Supply test"))))
                 return (aref vector index)))))
  
  (define-find-vector-variant :from-end false :test eq :key identity)
  (define-find-vector-variant :from-end false :test-not eq :key other)
  (define-find-vector-variant :from-end false :test eql :key identity)
  (define-find-vector-variant :from-end false :test-not eql :key other)
  (define-find-vector-variant :from-end false :test other :key identity)
  (define-find-vector-variant :from-end false :test other :key other)
  
  (define-find-vector-variant :from-end true :test eq :key identity)
  (define-find-vector-variant :from-end true :test-not eq :key other)
  (define-find-vector-variant :from-end true :test eql :key identity)
  (define-find-vector-variant :from-end true :test-not eql :key other)
  (define-find-vector-variant :from-end true :test other :key identity)
  (define-find-vector-variant :from-end true :test other :key other)
  
  (defun |find from-end=false end=nil test=eq key=identity|
      (item sequence start)
  