anchor.diff:    (if key
         (if test
             (if (or (eq test #'eq) (eq test 'eq))
  -              (member-eq-key 'member item list key)
  +              (|member test=eq key=other| 'member item list key)
                 (if (or (eq test #'eql) (eq test 'eql))
  -                  (member-eql-key 'member item list key)
  -                  (member-test-key 'member item list test key)))
  +                  (|member test=eql key=other| 'member item list key)
  +                  (|member test=other key=other| 'member item list test key)))
             (if test-not
                 (if (or (eq test-not #'eq) (eq test-not 'eq))
  -                  (member-not-eq-key 'member item list key)
  +                  (|member-test-not=eq key=other| 'member item list key)
                     (if (or (eq test-not #'eql) (eq test-not 'eql))
  -                      (member-not-eql-key 'member item list key)
  -                      (member-test-not-key 'member item list test-not key)))
  -              (member-eql-key 'member item list key)))
  +                      (|member-test-not=eql key=other| 'member item list key)
  +                      (|member test-not=other key=other| 'member item list test-not key)))
  +              (|member test=eql key=other| 'member item list key)))
         (if test
             (if (or (eq test #'eq) (eq test 'eq))
  -              (member-eq-identity 'member item list)
  +              (|member test=eq key=identity| 'member item list)
                 (if (or (eq test #'eql) (eq test 'eql))
  -                  (member-eql-identity 'member item list)
  -                  (member-test-identity 'member item list test)))
  +                  (|member test=eql key=identity| 'member item list)
  +                  (|member test=other key=identity| 'member item list test)))
             (if test-not
                 (if (or (eq test-not #'eq) (eq test-not 'eq))
  -                  (member-not-eq-identity 'member item list)
  +                  (|member-test-not=eq key=identity| 'member item list)
                     (if (or (eq test-not #'eql) (eq test-not 'eql))
  -                      (member-not-eql-identity 'member item list)
  -                      (member-test-not-identity 'member item list test-not)))
  -              (member-eql-identity 'member item list)))))
  +                      (|member-test-not=eql key=identity| 'member item list)
  +                      (|member test-not=other key=identity| 'member item list test-not)))
  +              (|member test=eql key=identity| 'member item list)))))
  +
  +;;; Special versions of the member function with the arguments
  +;;; of the test reversed.
  +
  +(defun |member reversed-test=other key=identity| (name item list test)
  +  (with-proper-list-rests (rest list name)
  +    (when (funcall test (car rest) item)
  +      (return rest))))
  +
  +(defun |member reversed-test=other key=other| (name item list test key)
  +  (with-proper-list-rests (rest list name)
  +    (when (funcall test (funcall key (car rest)) item)
  +      (return rest))))
  +
  +(defun |member reversed-test-not=other key=identity| (name item list test)
  +  (with-proper-list-rests (rest list name)
  +    (when (not (funcall test (car rest) item))
  +      (return rest))))
  +
  +(defun |member reversed-test-not=other key=other| (name item list test key)
  +  (with-proper-list-rests (rest list name)
  +    (when (not (funcall test (funcall key (car rest)) item))
  +      (return rest))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
   ;;; Function member-if
   
  -(defun member-if-identity (predicate list)
  +(defun |member-if key=identity| (predicate list)
     (with-proper-list-rests (rest list 'member-if)
       (when (funcall predicate (car rest))
         (return rest))))
   
  -(defun member-if-key (predicate list key)
  +(defun |member-if key=other| (predicate list key)
     (with-proper-list-rests (rest list 'member-if)
       (when (funcall predicate (funcall key (car rest)))
         (return rest))))
   
  -(defun member-if (predicate list &key key)
  +(defun |member-if| (predicate list &key key)
     (if key
  -      (member-if-key predicate list key)
  -      (member-if-identity predicate list)))
  +      (|member-if key=other| predicate list key)
  +      (|member-if key=identity| predicate list)))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
   ;;; Function member-if-not
   
  -(defun member-if-not-identity (predicate list)
  +(defun |member-if-not key=identity| (predicate list)
     (with-proper-list-rests (rest list 'member-if-not)
       (unless (funcall predicate (car rest))
         (return rest))))
   
  -(defun member-if-not-key (predicate list key)
  +(defun |member-if-not key=other| (predicate list key)
     (with-proper-list-rests (rest list 'member-if-not)
       (unless (funcall predicate (funcall key (car rest)))
         (return rest))))
   
  -(defun member-if-not (predicate list &key key)
  +(defun |member-if-not| (predicate list &key key)
     (if key
  -      (member-if-not-key predicate list key)
  -      (member-if-not-identity predicate list)))
  +      (|member-if-not key=other| predicate list key)
  +      (|member-if-not key=identity| predicate list)))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  
positive.code: ;;; Function adjoin
  
  (defun adjoin-identity-eq (name item list)
    (if (member-eq-identity name item list)
        list
        (cons item list)))
  
  (defun adjoin-identity-eql (name item list)
    (if (member-eql-identity name item list)
        list
        (cons item list)))
  
  (defun adjoin-identity-test (name item list test)
    (if (member-test-identity name item list test)
        list
        (cons item list)))
  
  (defun adjoin-identity-test-not (name item list test-not)
    (if (member-test-not-identity name item list test-not)
        list
        (cons item list)))
  
  (defun adjoin-key-eq (name item list key)
    (if (member-eq-key name (funcall key item) list key)
        list
        (cons item list)))
  
  (defun adjoin-key-eql (name item list key)
    (if (member-eql-key name (funcall key item) list key)
        list
        (cons item list)))
  
  (defun adjoin-key-test (name item list key test)
    (if (member-test-key name (funcall key item) list test key)
        list
        (cons item list)))
  
  (defun adjoin-key-test-not (name item list key test-not)
    (if (member-test-not-key name (funcall key item) list test-not key)
        list
        (cons item list)))
  
  
negative.code: ;;;
  ;;; Function set-exclusive-or
  
  (defun set-exclusive-or-identity-eql (name list1 list2)
    (let ((result '()))
      (with-proper-list-elements (element list1 name)
        (unless (|member test=eql key=identity| name element list2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (|member test=eql key=identity| name element list1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-identity-eq (name list1 list2)
    (let ((result '()))
      (with-proper-list-elements (element list1 name)
        (unless (|member test=eq key=identity| name element list2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (|member test=eq key=identity| name  element list1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-eql (name list1 list2 key)
    (let ((result '()))
      (with-proper-list-elements (element list1 name)
        (unless (|member test=eql key=other| name (funcall key element) list2 key)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (|member test=eql key=other| name (funcall key element) list1 key)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-eq (name list1 list2 key)
    (let ((result '()))
      (with-proper-list-elements (element list1 name)
        (unless (|member test=eq key=other| name (funcall key element) list2 key)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (|member test=eq key=other| name (funcall key element) list1 key)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-identity-test (name list1 list2 test)
    (let ((result '()))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=other key=identity| name element1 list2 test)
  	(push element1 result)))
      ;; we need to use a member with a test with reversed order or arguments
      (with-proper-list-elements (element2 list2 name)
        (unless (|member reversed-test=other key=identity| name element2 list1 test)
  	(push element2 result)))
      result))
  
  (defun set-exclusive-or-key-test (name list1 list2 key test)
    (let ((result '()))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=other key=other| name (funcall key element1) list2 test key)
  	(push element1 result)))
      ;; we need to use a member with a test with reversed order or arguments
      (with-proper-list-elements (element2 list2 name)
        (unless (|member reversed-test=other key=other| name (funcall key element2) list1 test key)
  	(push element2 result)))
      result))
  
  (defun set-exclusive-or-identity-test-not (name list1 list2 test-not)
    (let ((result '()))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test-not=other key=identity| name element1 list2 test-not)
  	(push element1 result)))
      ;; we need to use a member with a test with reversed order or arguments
      (with-proper-list-elements (element2 list2 name)
        (unless (|member reversed-test-not=other key=identity| name element2 list1 test-not)
  	(push element2 result)))
      result))
  
  (defun set-exclusive-or-key-test-not (name list1 list2 key test-not)
    (let ((result '()))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test-not=other key=other| name (funcall key element1) list2 test-not key)
  	(push element1 result)))
      ;; we need to use a member with a test with reversed order or arguments
      (with-proper-list-elements (element2 list2 name)
        (unless (|member reversed-test-not=other key=other| name (funcall key element2) list1 test-not key)
  	(push element2 result)))
      result))
  
  (defun set-exclusive-or-identity-eq-hash (name list1 list2)
    (let ((table1 (make-hash-table :test #'eq))
  	(table2 (make-hash-table :test #'eq))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash element table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash element table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash element table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash element table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-identity-eql-hash (name list1 list2)
    (let ((table1 (make-hash-table :test #'eql))
  	(table2 (make-hash-table :test #'eql))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash element table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash element table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash element table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash element table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-identity-equal-hash (name list1 list2)
    (let ((table1 (make-hash-table :test #'equal))
  	(table2 (make-hash-table :test #'equal))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash element table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash element table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash element table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash element table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-identity-equalp-hash (name list1 list2)
    (let ((table1 (make-hash-table :test #'equalp))
  	(table2 (make-hash-table :test #'equalp))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash element table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash element table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash element table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash element table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-eq-hash (name list1 list2 key)
    (let ((table1 (make-hash-table :test #'eq))
  	(table2 (make-hash-table :test #'eq))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash (funcall key element) table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash (funcall key element) table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash (funcall key element) table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash (funcall key element) table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-eql-hash (name list1 list2 key)
    (let ((table1 (make-hash-table :test #'eql))
  	(table2 (make-hash-table :test #'eql))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash (funcall key element) table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash (funcall key element) table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash (funcall key element) table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash (funcall key element) table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-equal-hash (name list1 list2 key)
    (let ((table1 (make-hash-table :test #'equal))
  	(table2 (make-hash-table :test #'equal))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash (funcall key element) table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash (funcall key element) table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash (funcall key element) table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash (funcall key element) table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or-key-equalp-hash (name list1 list2 key)
    (let ((table1 (make-hash-table :test #'equalp))
  	(table2 (make-hash-table :test #'equalp))
  	(result '()))
      (with-proper-list-elements (element list1 name)
        (setf (gethash (funcall key element) table1) t))
      (with-proper-list-elements (element list2 name)
        (setf (gethash (funcall key element) table2) t))
      (with-proper-list-elements (element list1 name)
        (unless (gethash (funcall key element) table2)
  	(push element result)))
      (with-proper-list-elements (element list2 name)
        (unless (gethash (funcall key element) table1)
  	(push element result)))
      result))
  
  (defun set-exclusive-or (list1 list2 &key key test test-not)
  