anchor.diff:  	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (set-exclusive-or-key-eq-hash list1 list2 key)
  -		       (set-exclusive-or-key-eq list1 list2 key)))
  +		       (set-exclusive-or-key-eq-hash 'set-exclusive-or list1 list2 key)
  +		       (set-exclusive-or-key-eq 'set-exclusive-or list1 list2 key)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (set-exclusive-or-key-eql-hash list1 list2 key)
  -		       (set-exclusive-or-key-eql list1 list2 key)))
  +		       (set-exclusive-or-key-eql-hash 'set-exclusive-or list1 list2 key)
  +		       (set-exclusive-or-key-eql 'set-exclusive-or list1 list2 key)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (set-exclusive-or-key-equal-hash list1 list2 key)
  -		       (set-exclusive-or-key-test list1 list2 key #'equal)))
  +		       (set-exclusive-or-key-equal-hash 'set-exclusive-or list1 list2 key)
  +		       (set-exclusive-or-key-test 'set-exclusive-or list1 list2 key #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (set-exclusive-or-key-equalp-hash list1 list2 key)
  -		       (set-exclusive-or-key-test list1 list2 key #'equalp)))
  +		       (set-exclusive-or-key-equalp-hash 'set-exclusive-or list1 list2 key)
  +		       (set-exclusive-or-key-test 'set-exclusive-or list1 list2 key #'equalp)))
   		  (t
  -		   (set-exclusive-or-key-test list1 list2 key test)))
  +		   (set-exclusive-or-key-test 'set-exclusive-or list1 list2 key test)))
   	    (if test-not
  -		(set-exclusive-or-key-test-not list1 list2 key test-not)
  +		(set-exclusive-or-key-test-not 'set-exclusive-or list1 list2 key test-not)
   		(if use-hash
  -		    (set-exclusive-or-key-eql-hash list1 list2 key)
  -		    (set-exclusive-or-key-eql list1 list2 key))))
  +		    (set-exclusive-or-key-eql-hash 'set-exclusive-or list1 list2 key)
  +		    (set-exclusive-or-key-eql 'set-exclusive-or list1 list2 key))))
   	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (set-exclusive-or-identity-eq-hash list1 list2)
  -		       (set-exclusive-or-identity-eq list1 list2)))
  +		       (set-exclusive-or-identity-eq-hash 'set-exclusive-or list1 list2)
  +		       (set-exclusive-or-identity-eq 'set-exclusive-or list1 list2)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (set-exclusive-or-identity-eql-hash list1 list2)
  -		       (set-exclusive-or-identity-eql list1 list2)))
  +		       (set-exclusive-or-identity-eql-hash 'set-exclusive-or list1 list2)
  +		       (set-exclusive-or-identity-eql 'set-exclusive-or list1 list2)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (set-exclusive-or-identity-equal-hash list1 list2)
  -		       (set-exclusive-or-identity-test list1 list2 #'equal)))
  +		       (set-exclusive-or-identity-equal-hash 'set-exclusive-or list1 list2)
  +		       (set-exclusive-or-identity-test 'set-exclusive-or list1 list2 #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (set-exclusive-or-identity-equalp-hash list1 list2)
  -		       (set-exclusive-or-identity-test list1 list2 #'equalp)))
  +		       (set-exclusive-or-identity-equalp-hash 'set-exclusive-or list1 list2)
  +		       (set-exclusive-or-identity-test 'set-exclusive-or list1 list2 #'equalp)))
   		  (t
  -		   (set-exclusive-or-identity-test list1 list2 test)))
  +		   (set-exclusive-or-identity-test 'set-exclusive-or list1 list2 test)))
   	    (if test-not
  -		(set-exclusive-or-identity-test-not list1 list2 test-not)
  +		(set-exclusive-or-identity-test-not 'set-exclusive-or list1 list2 test-not)
   		(if use-hash
  -		    (set-exclusive-or-identity-eql-hash list1 list2)
  -		    (set-exclusive-or-identity-eql list1 list2)))))))
  +		    (set-exclusive-or-identity-eql-hash 'set-exclusive-or list1 list2)
  +		    (set-exclusive-or-identity-eql 'set-exclusive-or list1 list2)))))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  
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: (defun union-identity-eql (name list1 list2)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=eql key=identity| name element1 list2)
  	(push element1 result)))
      result))
  
  (defun union-identity-eq (name list1 list2)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=eq key=identity| name element1 list2)
  	(push element1 result)))
      result))
  
  (defun union-key-eql (name list1 list2 key)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=eql key=other| name (funcall key element1) list2 key)
  	(push element1 result)))
      result))
  
  (defun union-key-eq (name list1 list2 key)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=eq key=other| name (funcall key element1) list2 key)
  	(push element1 result)))
      result))
  
  (defun union-identity-test (name list1 list2 test)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=other key=identity| name element1 list2 test)
  	(push element1 result)))
      result))
  
  (defun union-key-test (name list1 list2 key test)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test=other key=other| name (funcall key element1 ) list2 test key)
  	(push element1 result)))
      result))
  
  (defun union-identity-test-not (name list1 list2 test-not)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test-not=other key=identity| name element1 list2 test-not)
  	(push element1 result)))
      result))
  
  (defun union-key-test-not (name list1 list2 key test-not)
    (let ((result list2))
      (with-proper-list-elements (element1 list1 name)
        (unless (|member test-not=other key=other| name element1 list2 test-not key)
  	(push element1 result)))
      result))
  
  