anchor.diff:  ;; generics
   ;; ---------------------------------------------------------------------------------------------------------------------
   
  -(defgeneric allocate-location (transaction obj))
  -
  -(defgeneric object-for-location (transaction location))
  -
  -(defgeneric location-for-object (transaction obj))
  +(defgeneric allocate-id (transaction obj))
  +
  +(defgeneric object-for-id (transaction id))
  +
  +(defgeneric id-for-object (transaction obj))
   
   (defgeneric add-changed-node (transaction node))
   
  -(defgeneric add-opened-node (transaction node location))
  +(defgeneric add-opened-node (transaction node id))
   
   (defgeneric prb-open-storage (storage)
     (:documentation "Prepare storage for use; after this call load & save operations should succeed"))
  
positive.code: 	     `(progn
  		(defmethod ,slot :around ((node persistent-red-black-node))
  		  (require-rb-transaction)
  		  (let ((location (call-next-method)))
  		    (or (object-for-location *rb-transaction* location)
  			(let ((node (prb-load (storage (tree *rb-transaction*)) location)))
  			  (add-opened-node *rb-transaction* node location)
  			  node))))
  
  		(defmethod (setf ,slot) :around (value (node persistent-red-black-node))
  		  (require-rb-transaction)
  		  (add-changed-node *rb-transaction* node)
  		  ;; (format *standard-output* "Setting slot ~s with value ~s~%" ',slot (location-for-object *rb-transaction* value))
  		  (call-next-method (location-for-object *rb-transaction* value) node)))))
    (declare-slot-translation parent)
    (declare-slot-translation left)
    (declare-slot-translation right))
  
negative.code: 
  (defmethod root :around ((tree persistent-red-black-tree))
    (require-rb-transaction)
    (let ((id (or (and *rb-transaction* (new-root *rb-transaction*)) (call-next-method))))
      (or (object-for-id *rb-transaction* id)
  	(let ((root (prb-load (storage tree) id)))
  	  (add-opened-node *rb-transaction* root id)
  	  root))))
  
  (defmethod (setf root) (node (tree persistent-red-black-tree))
    (require-rb-transaction)
    (add-changed-node *rb-transaction* node)
    (setf (new-root *rb-transaction*) (id-for-object *rb-transaction* node)))
  
  (defmethod allocate-id ((*rb-transaction* red-black-tree-transaction) obj)
    (allocate-id (storage (tree *rb-transaction*)) obj))
  
  (defmethod allocate-id ((storage red-black-tree-memory-storage) obj)
    (declare (ignorable obj))
    (let ((next-id (next-id storage)))
      (incf (next-id storage))
      next-id))
  
  (defmethod object-for-id ((*rb-transaction* red-black-tree-transaction) id)
    (gethash id (id-to-object *rb-transaction*)))
  
  (defmethod id-for-object ((*rb-transaction* red-black-tree-transaction) obj)
    (let ((id (gethash obj (object-to-id *rb-transaction*))))
      (if id
  	id
  	(let ((new-id (allocate-id *rb-transaction* obj)))
  	  (setf (gethash obj (object-to-id *rb-transaction*)) new-id)
  	  (setf (gethash id (id-to-object *rb-transaction*)) obj)
  	  new-id))))
  
  (defmethod rb-make-node :around ((tree persistent-red-black-tree) &key ((:key key) nil) ((:data data) nil))
    (declare (ignorable key data))
  