anchor.diff:  	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (union-key-eq-hash list1 list2 key)
  -		       (union-key-eq list1 list2 key)))
  +		       (union-key-eq-hash 'nunion list1 list2 key)
  +		       (union-key-eq 'nunion list1 list2 key)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (union-key-eql-hash list1 list2 key)
  -		       (union-key-eql list1 list2 key)))
  +		       (union-key-eql-hash 'nunion list1 list2 key)
  +		       (union-key-eql 'nunion list1 list2 key)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (union-key-equal-hash list1 list2 key)
  -		       (union-key-test list1 list2 key #'equal)))
  +		       (union-key-equal-hash 'nunion list1 list2 key)
  +		       (union-key-test 'nunion list1 list2 key #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (union-key-equalp-hash list1 list2 key)
  -		       (union-key-test list1 list2 key #'equalp)))
  +		       (union-key-equalp-hash 'nunion list1 list2 key)
  +		       (union-key-test 'nunion list1 list2 key #'equalp)))
   		  (t
  -		   (union-key-test list1 list2 key test)))
  +		   (union-key-test 'nunion list1 list2 key test)))
   	    (if test-not
  -		(union-key-test-not list1 list2 key test-not)
  +		(union-key-test-not 'nunion list1 list2 key test-not)
   		(if use-hash
  -		    (union-key-eql-hash list1 list2 key)
  -		    (union-key-eql list1 list2 key))))
  +		    (union-key-eql-hash 'nunion list1 list2 key)
  +		    (union-key-eql 'nunion list1 list2 key))))
   	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (union-identity-eq-hash list1 list2)
  -		       (union-identity-eq list1 list2)))
  +		       (union-identity-eq-hash 'nunion list1 list2)
  +		       (union-identity-eq 'nunion list1 list2)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (union-identity-eql-hash list1 list2)
  -		       (union-identity-eql list1 list2)))
  +		       (union-identity-eql-hash 'nunion list1 list2)
  +		       (union-identity-eql 'nunion list1 list2)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (union-identity-equal-hash list1 list2)
  -		       (union-identity-test list1 list2 #'equal)))
  +		       (union-identity-equal-hash 'nunion list1 list2)
  +		       (union-identity-test 'nunion list1 list2 #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (union-identity-equalp-hash list1 list2)
  -		       (union-identity-test list1 list2 #'equalp)))
  +		       (union-identity-equalp-hash 'nunion list1 list2)
  +		       (union-identity-test 'nunion list1 list2 #'equalp)))
   		  (t
  -		   (union-identity-test list1 list2 test)))
  +		   (union-identity-test 'nunion list1 list2 test)))
   	    (if test-not
  -		(union-identity-test-not list1 list2 test-not)
  +		(union-identity-test-not 'nunion list1 list2 test-not)
   		(if use-hash
  -		    (union-identity-eql-hash list1 list2)
  -		    (union-identity-eql list1 list2)))))))
  +		    (union-identity-eql-hash 'nunion list1 list2)
  +		    (union-identity-eql 'nunion list1 list2)))))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
   ;;; Function intersection
   
  -(defun intersection-identity-eql (list1 list2)
  +(defun intersection-identity-eql (name list1 list2)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (eql element1 (car rest2))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (eql element1 element2)
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-identity-eq (list1 list2)
  +(defun intersection-identity-eq (name list1 list2)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (eq element1 (car rest2))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (eq element1 element2)
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-key-eql (list1 list2 key)
  +(defun intersection-key-eql (name list1 list2 key)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (eql (funcall key element1) (funcall key (car rest2)))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (eql (funcall key element1) (funcall key element2))
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-key-eq (list1 list2 key)
  +(defun intersection-key-eq (name list1 list2 key)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (eq (funcall key element1) (funcall key (car rest2)))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (eq (funcall key element1) (funcall key element2))
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-identity-test (list1 list2 test)
  +(defun intersection-identity-test (name list1 list2 test)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (funcall test element1 (car rest2))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (funcall test element1 element2)
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-key-test (list1 list2 key test)
  +(defun intersection-key-test (name list1 list2 key test)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(when (funcall test (funcall key element1) (funcall key (car rest2)))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (when (funcall test (funcall key element1) (funcall key element2))
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-identity-test-not (list1 list2 test-not)
  +(defun intersection-identity-test-not (name list1 list2 test-not)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(unless (funcall test-not element1 (car rest2))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (unless (funcall test-not element1 element2)
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-key-test-not (list1 list2 key test-not)
  +(defun intersection-key-test-not (name list1 list2 key test-not)
     (let ((result '()))
  -    (with-proper-list-rests (rest1 list1 intersection)
  -      (let ((element1 (car rest1)))
  -	(when (with-proper-list-rests (rest2 list2 intersection)
  -		(unless (funcall test-not (funcall key element1) (funcall key (car rest2)))
  -		  (return t)))
  -	  (push element1 result))))
  +    (with-proper-list-elements (element1 list1 name)
  +      (when (with-proper-list-elements (element2 list2 name)
  +	      (unless (funcall test-not (funcall key element1) (funcall key element2))
  +		(return t)))
  +	(push element1 result)))
       result))
   
  -(defun intersection-identity-eq-hash (list1 list2)
  +(defun intersection-identity-eq-hash (name list1 list2)
     (let ((table (make-hash-table :test #'eq))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash element table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash element table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash element table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash element table)
  +	(push element result)))
       result))
   
  -(defun intersection-identity-eql-hash (list1 list2)
  +(defun intersection-identity-eql-hash (name list1 list2)
     (let ((table (make-hash-table :test #'eql))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash element table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash element table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash element table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash element table)
  +	(push element result)))
       result))
   
  -(defun intersection-identity-equal-hash (list1 list2)
  +(defun intersection-identity-equal-hash (name list1 list2)
     (let ((table (make-hash-table :test #'equal))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash element table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash element table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash element table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash element table)
  +	(push element result)))
       result))
   
  -(defun intersection-identity-equalp-hash (list1 list2)
  +(defun intersection-identity-equalp-hash (name list1 list2)
     (let ((table (make-hash-table :test #'equalp))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash element table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash element table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash element table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash element table)
  +	(push element result)))
       result))
   
  -(defun intersection-key-eq-hash (list1 list2 key)
  +(defun intersection-key-eq-hash (name list1 list2 key)
     (let ((table (make-hash-table :test #'eq))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash (funcall key element) table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash (funcall key element) table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash (funcall key element) table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash (funcall key element) table)
  +	(push element result)))
       result))
   
  -(defun intersection-key-eql-hash (list1 list2 key)
  +(defun intersection-key-eql-hash (name list1 list2 key)
     (let ((table (make-hash-table :test #'eql))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash (funcall key element) table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash (funcall key element) table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash (funcall key element) table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash (funcall key element) table)
  +	(push element result)))
       result))
   
  -(defun intersection-key-equal-hash (list1 list2 key)
  +(defun intersection-key-equal-hash (name list1 list2 key)
     (let ((table (make-hash-table :test #'equal))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash (funcall key element) table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash (funcall key element) table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash (funcall key element) table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash (funcall key element) table)
  +	(push element result)))
       result))
   	 
  -(defun intersection-key-equalp-hash (list1 list2 key)
  +(defun intersection-key-equalp-hash (name list1 list2 key)
     (let ((table (make-hash-table :test #'equalp))
   	(result '()))
  -    (with-proper-list-rests (rest list2 intersection)
  -      (let ((element (car rest)))
  -	(setf (gethash (funcall key element) table) t)))
  -    (with-proper-list-rests (rest list1 intersection)
  -      (let ((element (car rest)))
  -	(when (gethash (funcall key element) table)
  -	  (push element result))))
  +    (with-proper-list-elements (element list2 name)
  +      (setf (gethash (funcall key element) table) t))
  +    (with-proper-list-elements (element list1 name)
  +      (when (gethash (funcall key element) table)
  +	(push element result)))
       result))
   
   (defun intersection (list1 list2 &key key test test-not)
  
positive.code: 	   finally (unless (null ,rest-var)
  		     (error 'must-be-proper-list
  			    :datum ,list-var
  			    :name ',function-name)))))
  
  (defun member-eq-identity (item list)
    (with-proper-list-rests (rest list member)
      (when (eq item (car rest))
        (return rest))))
  
  (defun member-eq-key (item list key)
    (with-proper-list-rests (rest list member)
      (when (eq item (funcall key (car rest)))
        (return rest))))
  
  (defun member-not-eq-identity (item list)
    (with-proper-list-rests (rest list member)
      (when (not (eq item (car rest)))
        (return rest))))
  
  (defun member-not-eq-key (item list key)
    (with-proper-list-rests (rest list member)
      (when (not (eq item (funcall key (car rest))))
        (return rest))))
  
  (defun member-eql-identity (item list)
    (with-proper-list-rests (rest list member)
      (when (eql item (car rest))
        (return rest))))
  
  (defun member-eql-key (item list key)
    (with-proper-list-rests (rest list member)
      (when (eql item (funcall key (car rest)))
        (return rest))))
  
  (defun member-not-eql-identity (item list)
    (with-proper-list-rests (rest list member)
      (when (not (eql item (car rest)))
        (return rest))))
  
  (defun member-not-eql-key (item list key)
    (with-proper-list-rests (rest list member)
      (when (not (eql item (funcall key (car rest))))
        (return rest))))
  
  (defun member-test-identity (item list test)
    (with-proper-list-rests (rest list member)
      (when (funcall test item (car rest))
        (return rest))))
  
  (defun member-test-key (item list test key)
    (with-proper-list-rests (rest list member)
      (when (funcall test item (funcall key (car rest)))
        (return rest))))
  
  (defun member-test-not-identity (item list test)
    (with-proper-list-rests (rest list member)
      (when (not (funcall test item (car rest)))
        (return rest))))
  
  (defun member-test-not-key (item list test key)
    (with-proper-list-rests (rest list member)
      (when (not (funcall test item (funcall key (car rest))))
        (return rest))))
  
  
negative.code:   (if key
        (if test
            (if (or (eq test #'eq) (eq test 'eq))
                (member-eq-key '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)))
            (if test-not
                (if (or (eq test-not #'eq) (eq test-not 'eq))
                    (member-not-eq-key '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)))
        (if test
            (if (or (eq test #'eq) (eq test 'eq))
                (member-eq-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)))
            (if test-not
                (if (or (eq test-not #'eq) (eq test-not 'eq))
                    (member-not-eq-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)))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Function member-if
  
  (defun member-if-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)
    (with-proper-list-rests (rest list 'member-if)
      (when (funcall predicate (funcall key (car rest)))
        (return rest))))
  
  