anchor.diff:  ;;; 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 ~
  +  "find seq-type=~a from-end=~a ~@[end=~a ~]~
           ~@[test=~a~]~@[test-not=~a~] key=~a")
   
   (defmacro define-find-list-variant
  
positive.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)
  
  (defun |find seq-type=vector from=end=nil test=eq key=identity|
      (item vector start end)
    (loop for index from start below end
          when (eq item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test=eq key=other|
      (item vector start end key)
    (loop for index from start below end
          when (eq item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=eq key=identity|
      (item vector start end)
    (loop for index from start below end
          when (not (eq item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=eq key=other|
      (item vector start end key)
    (loop for index from start below end
          when (not (eq item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test=eql key=identity|
      (item vector start end)
    (loop for index from start below end
          when (eql item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test=eql key=other|
      (item vector start end key)
    (loop for index from start below end
          when (eql item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=eql key=identity|
      (item vector start end)
    (loop for index from start below end
          when (not (eql item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=eql key=other|
      (item vector start end key)
    (loop for index from start below end
          when (not (eql item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test=other key=identity|
      (item vector start end test)
    (loop for index from start below end
          when (funcall test item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test=other key=other|
      (item vector start end test key)
    (loop for index from start below end
          when (funcall test item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=other key=identity|
      (item vector start end test)
    (loop for index from start below end
          when (not (funcall test item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from=end=nil test-not=other key=other|
      (item vector start end test key)
    (loop for index from start below end
          when (not (funcall test item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=eq key=identity|
      (item vector start end)
    (loop for index downfrom (1- end) to start
          when (eq item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=eq key=other|
      (item vector start end key)
    (loop for index downfrom (1- end) to start
          when (eq item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=eq key=identity|
      (item vector start end)
    (loop for index downfrom (1- end) to start
          when (not (eq item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=eq key=other|
      (item vector start end key)
    (loop for index downfrom (1- end) to start
          when (not (eq item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=eql key=identity|
      (item vector start end)
    (loop for index downfrom (1- end) to start
          when (eql item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=eql key=other|
      (item vector start end key)
    (loop for index downfrom (1- end) to start
          when (eql item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=eql key=identity|
      (item vector start end)
    (loop for index downfrom (1- end) to start
          when (not (eql item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=eql key=other|
      (item vector start end key)
    (loop for index downfrom (1- end) to start
          when (not (eql item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=other key=identity|
      (item vector start end test)
    (loop for index downfrom (1- end) to start
          when (funcall test item (aref vector index))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test=other key=other|
      (item vector start end test key)
    (loop for index downfrom (1- end) to start
          when (funcall test item (funcall key (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=other key=identity|
      (item vector start end test)
    (loop for index downfrom (1- end) to start
          when (not (funcall test item (aref vector index)))
            return (aref vector index)))
  
  (defun |find seq-type=vector from-end=true test-not=other key=other|
      (item vector start end test key)
    (loop for index downfrom (1- end) to start
          when (not (funcall test item (funcall key (aref vector index))))
            return (aref vector index)))
  
  (defun |find from-end=false end=nil test=eq key=identity|
      (item sequence start)
  
negative.code:   (let ((function-name
            (intern (string-downcase
                     (format nil +find-function-name-format-control+
                             '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))))
  