anchor.diff:  (defclass red-black-tree-memory-storage (red-black-tree-storage)
     ((objects :initform (make-array 0 :adjustable t) :accessor objects)
      (root :accessor root)
  -   (next-location :initform 0 :accessor next-location)))
  +   (next-id :initform 0 :accessor next-id)))
   
   (defclass red-black-tree-file-storage (red-black-tree-storage)
     ((file-name :initarg :file-name :accessor file-name)))
  
positive.code: 
  (defmethod root :around ((tree persistent-red-black-tree))
    (require-rb-transaction)
    (let ((location (or (and *rb-transaction* (new-root *rb-transaction*)) (call-next-method))))
      (or (object-for-location *rb-transaction* location)
  	(let ((root (prb-load (storage tree) location)))
  	  (add-opened-node *rb-transaction* root location)
  	  root))))
  
  (defmethod (setf root) (node (tree persistent-red-black-tree))
    (require-rb-transaction)
    (add-changed-node *rb-transaction* node)
    (setf (new-root *rb-transaction*) (location-for-object *rb-transaction* node)))
  
  (defmethod allocate-location ((*rb-transaction* red-black-tree-transaction) obj)
    (allocate-location (storage (tree *rb-transaction*)) obj))
  
  (defmethod allocate-location ((storage red-black-tree-memory-storage) obj)
    (declare (ignorable obj))
    (let ((next-location (next-location storage)))
      (incf (next-location storage))
      next-location))
  
  (defmethod object-for-location ((*rb-transaction* red-black-tree-transaction) location)
    (gethash location (location-to-object *rb-transaction*)))
  
  (defmethod location-for-object ((*rb-transaction* red-black-tree-transaction) obj)
    (let ((location (gethash obj (object-to-location *rb-transaction*))))
      (if location
  	location
  	(let ((new-location (allocate-location *rb-transaction* obj)))
  	  (setf (gethash obj (object-to-location *rb-transaction*)) new-location)
  	  (setf (gethash location (location-to-object *rb-transaction*)) obj)
  	  new-location))))
  
  (defmethod rb-make-node :around ((tree persistent-red-black-tree) &key ((:key key) nil) ((:data data) nil))
    (declare (ignorable key data))
  
negative.code: ;; generics
  ;; ---------------------------------------------------------------------------------------------------------------------
  
  (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 id))
  
  (defgeneric prb-open-storage (storage)
    (:documentation "Prepare storage for use; after this call load & save operations should succeed"))
  