anchor.diff:  ;;; FIXME: do a better job here.
   (defmethod make-type-descriptor ((symbol (eql 'member)) rest)
     (make-t-type-descriptor))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
  +;;; Functions and classes for type maps.
  +;;;
  +;;; A type map is a dictionary mapping variables to type descriptors.
  +;;; We represent a type map as an EQ hash table.  Client code can use
  +;;; whatever object it wants to represent variables, as long as those
  +;;; objects can be compared using EQ.
  +;;;
  +;;; Only variables whose types are something other than T need
  +;;; acutally be present in the hash table.  
  +
  +(defun type-descriptor (variable type-map)
  +  (gethash variable type-map (make-t-type-descriptor)))
  +
  +(defun type-map-or (type-map-1 type-map-2)
  +  (let ((result (make-hash-table :test #'eq)))
  +    (maphash (lambda (key descriptor1)
  +	       (let ((descriptor2 (gethash key type-map-2)))
  +		 (unless (null descriptor2)
  +		   (setf (gethash key result)
  +			 (type-descriptor-or descriptor1 descriptor2)))))
  +	     type-map-1)
  +    result))
  +
  +(defun type-map-and (type-map-1 type-map-2)
  +  (let ((result (make-hash-table :test #'eq)))
  +    (maphash (lambda (key descriptor1)
  +	       (let ((descriptor2 (gethash key type-map-2)))
  +		 (setf (gethash key result)
  +		       (if (null descriptor2)
  +			   descriptor1
  +			   (type-descriptor-and descriptor1 descriptor2)))))
  +	     type-map-1)
  +    (maphash (lambda (key descriptor2)
  +	       (let ((descriptor1 (gethash key type-map-1)))
  +		 (when (null descriptor1)
  +		   (setf (gethash key result)
  +			 descriptor2))))
  +	     type-map-2)
  +    result))
  +    
  +(defun type-map-diff (type-map-1 type-map-2)
  +  (let ((result (make-hash-table :test #'eq)))
  +    (maphash (lambda (key descriptor1)
  +	       (let ((descriptor2 (gethash key type-map-2)))
  +		 (setf (gethash key result)
  +		       (type-descriptor-diff
  +			descriptor1
  +			(if (null descriptor2)
  +			    (make-t-type-descriptor)
  +			    descriptor2)))))
  +	     type-map-1)
  +    (maphash (lambda (key descriptor2)
  +	       (let ((descriptor1 (gethash key type-map-1)))
  +		 (when (null descriptor1)
  +		   (setf (gethash key result)
  +			 (type-descriptor-diff
  +			  (make-t-type-descriptor)
  +			  descriptor2)))))
  +	     type-map-2)
  +    result))
  
positive.code:     :others-descriptor (others-diff (others-descriptor descriptor1)
  			            (others-descriptor descriptor2))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Canonicalization.
  ;;;
  
negative.code: 	     nil
  	     descriptor1))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; NULL descriptor.
  ;;;
  