anchor.diff:  ;;; SLOT-MAKUNBOUND, SLOT-MAKUNBOUND-USING-CLASS.
   
   (defgeneric slot-makunbound-using-class (class object slot))
  +
  +(defun slot-makunbound-using-class-aux (object slot)
  +  (let ((location (slot-definition-location slot)))
  +    (if (consp location)
  +	(setf (car location) *unbound-value*)
  +  	(setf (slot-contents (heap-instance-slots object) location)
  +	      *unbound-value*)))
  +  nil)
   
   (defmethod slot-makunbound-using-class
     ((class standard-class)
      object
  -   (slot standard-effectove-slot-definition))
  -  (declare (ignore class))
  -  (let ((location (slot-definition-location slot)))
  -    (if (consp location)
  -	(setf (car location) *secret-unbound-value*)
  -  	(setf (slot-contents (standard-instance-slots object) location)
  -	      *secret-unbound-value*))))
  +   (slot standard-effective-slot-definition))
  +  (slot-makunbound-using-class-aux object slot))
   
   (defmethod slot-makunbound-using-class
     ((class funcallable-standard-class)
      object
  -   (slot standard-effectove-slot-definition))
  -  (declare (ignore class))
  -  (let ((location (slot-definition-location slot)))
  -    (if (consp location)
  -	(setf (car location) *secret-unbound-value*)
  -  	(setf (slot-contents (standard-instance-slots object) location)
  -	      *secret-unbound-value*))))
  +   (slot standard-effective-slot-definition))
  +  (slot-makunbound-using-class-aux object slot))
   
   (defmethod slot-makunbound-using-class
     ((class built-in-class)
  
positive.code: 
  (defgeneric slot-value-using-class (class object slot))
  
  (defmethod slot-value-using-class ((class standard-class)
  				   object
  				   (slot standard-effectove-slot-definition))
    (declare (ignore class))
    (let* ((location (slot-definition-location slot))
  	 (value 
  	   (if (consp location)
  	       (car location)
  	       (slot-contents (standard-instance-slots object)
  			      location))))
      (if (eq value *secret-unbound-value*)
  	(slot-unbound class object (slot-definition-name slot))
  	value)))
  
  (defmethod slot-value-using-class ((class funcallable-standard-class)
  				   object
  				   (slot standard-effectove-slot-definition))
    (declare (ignore class))
    (let* ((location (slot-definition-location slot))
  	 (value 
  	   (if (consp location)
  	       (car location)
  	       (slot-contents (standard-instance-slots object)
  			      location))))
      (if (eq value *secret-unbound-value*)
  	(slot-unbound class object (slot-definition-name slot))
  	value)))
  
  (defmethod slot-value-using-class ((class built-in-class)
  				   object
  				   slot)
    (error "no slots in an instance of a builtin class"))
  
  (defgeneric (setf slot-value-using-class) (new-value class object slot))
  
  (defmethod (setf slot-value-using-class)
    (new-value
     (class standard-class)
     object
     (slot standard-effectove-slot-definition))
    (declare (ignore class))
    (let ((location (slot-definition-location slot)))
      (if (consp location)
  	(setf (car location) new-value)
    	(setf (slot-contents (standard-instance-slots object) location)
  	      new-value))))
  
  (defmethod (setf slot-value-using-class)
    (new-value
     (class funcallable-standard-class)
     object
     (slot standard-effectove-slot-definition))
    (declare (ignore class))
    (let ((location (slot-definition-location slot)))
      (if (consp location)
  	(setf (car location) new-value)
    	(setf (slot-contents (standard-instance-slots object) location)
  	      new-value))))
  
  (defmethod (setf slot-value-using-class)
    (new-value
     (class built-in-class)
     object
     slot)
    (error "no slots in an instance of a builtin class"))
  
  (defun slot-value (object slot-name)
    (let ((slot (find-slot object slot-name))
  	(class (class-of object)))
      (if (null slot)
  	(slot-missing class object slot-name 'slot-value)
  	(slot-value-using-class class object slot))))
  
  (defun (setf slot-value) (new-value object slot-name)
    (let ((slot (find-slot object slot-name))
  	(class (class-of object)))
      (if (null slot)
  	(slot-missing class object slot-name 'slot-value)
  	(setf (slot-value-using-class class object slot) new-value))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  
negative.code: 
  (defgeneric slot-boundp-using-class (class object slot))
  
  (defun slot-boundp-using-class-aux (object slot)
    (let ((location (slot-definition-location slot)))
      (not (eq (if (consp location)
  		 (car location)
  		 (slot-contents (heap-instance-slots object) location))
  	     *unbound-value*))))
  
  (defmethod slot-boundp-using-class ((class standard-class)
  				    object
  				    (slot standard-effective-slot-definition))
    (slot-boundp-using-class-aux object slot))
  
  (defmethod slot-boundp-using-class ((class funcallable-standard-class)
  				    object
  				    (slot standard-effective-slot-definition))
    (slot-boundp-using-class-aux object slot))
  
  (defmethod slot-boundp-using-class ((class built-in-class)
  				    object
  				    slot)
    (declare (ignore object))
    (error "no slots in an instance of a builtin class"))
  
  (defun slot-boundp (object slot-name)
    ;; FIXME: We must check that the object is a standard instance.
    (let ((slot (find-slot object slot-name))
  	(class (class-of object)))
      ;; FIXME: check that the object is up to date.  
      (slot-boundp-using-class class object slot)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  