anchor.diff:  
   (defgeneric transactional-slots-using-class (object class)
     (declare (optimize speed))
  -  (:documentation "Return a list of slot-definitions to serialize.
  +  (:documentation "Return a list of transactional slot-definitions.
      The default calls compute slots with class")
     (:method ((object t) (class transactional-class))
  -    (remove '%lock (class-slots class) :key (lambda (obj)
  -					      (slot-value obj 'sb-pcl::name)))))
  +    (remove '%lock (remove 'requires-transaction
  +			   (class-slots class) :key (lambda (obj)
  +						      (slot-value obj 'sb-pcl::name)))
  +	    :key (lambda (obj)
  +						      (slot-value obj 'sb-pcl::name)))))
   
   (defmethod transactional-slot-p ((object transactional-object) slot-name)
     (some (lambda (slot)
  
positive.code: 	   (sb-thread:release-mutex (%lock object))))))
  
  (defmethod rollback-transaction ((transaction transaction))
    (setf (objects transaction) (make-hash-table)))
  
  (defmethod validate-superclass ((class transactional-class)
  				(superclass standard-class))
    t)
  
  (defun make-transaction ()
    (make-instance 'transaction))
  
  (defun start-transaction ()
    (setf *transaction* (make-transaction)))
  
  (defmacro with-transaction ((&optional (var '*transaction*))
  			    &body body)
    `(let ((,var (make-transaction)))
       ,@body
       (commit-transaction ,var)))
  
  (defmethod serializable-slots-using-class ((object t) (class transactional-class))
    (remove '%lock (call-next-method) :key (lambda (obj)
  
negative.code:     (loop for (version . object-copy) being the hash-values of (objects transaction)
         using (hash-key object)
         when (not (equalp (transactional-object-version object) version))
         do (error "~A is not valid: conflict in ~A (~A <> ~A)"
  		 transaction
  		 object
  		 (object-version object)
  		 version))))
  
  (defmethod commit-transaction ((transaction transaction))
    (let ((*transaction* nil))
  