anchor.diff:  		      (declare (,bag-type bag) (,rummager-type rummager))
   		      (unless (find rummager (,rummagers bag) :test #'eq)
   			(vector-push-extend rummager (,rummagers bag))
  -			(setf (,parent rummager) bag)
  +			(setf (,rummager-parent rummager) bag)
   			(loop :for item :across (,item-cache bag) :do
   			   (%parent-on-added rummager item)))
   		      bag)
  -		    (%remove-rummager (bag rummager)
  -		      (declare (,bag-type bag) (,rummager-type rummager))
  -		      (setf (,rummagers bag) (delete rummager (,rummagers bag) :count 1))
  -		      (setf (,parent rummager) nil)
  -		      bag)
  +		    (%remove-rummager (rummager)
  +		      (declare (,rummager-type rummager))
  +		      (let ((bag (,rummager-parent rummager)))
  +			(declare (,bag-type bag))
  +			(setf (,rummagers bag)
  +			      (delete rummager (,rummagers bag) :count 1))
  +			(setf (,rummager-parent rummager) nil)
  +			bag))
   		    (%parent-on-added (rummager item)
   		      (declare (,rummager-type rummager) (,element-type item))
  -		      (when (funcall (,predicate rummager)
  -				     item)
  -			(,add-item rummager item)))
  +		      (when (funcall (,predicate rummager) item)
  +			(,add-item (,rummager-bag rummager) item)))
   		    (%parent-on-removed (rummager item)
   		      (declare (,rummager-type rummager) (,element-type item))
  -		      (,remove-item rummager item nil)))
  -
  -	     (defun ,(symb 'bag-of- element-type '!) (&optional (min-extension 100))
  +		      (,remove-item (,rummager-bag rummager) item nil)))
  +
  +	     (defun ,init (&optional (min-extension 100))
   	       (declare (fixnum min-extension))
  -	       (,(symb 'make- bag-type) :extension min-extension))
  +	       (,(symb 'make- bag-type) :extension min-extension
  +		 :rummagers (make-array 0 :element-type ',rummager-type
  +					:adjustable t :fill-pointer 0)))
   
   	     (defun ,(symb 'destroy- element-type '-bag) (bag)
   	       (declare (,bag-type bag))
  
positive.code: ;; - make remove-item handled 1 item and 0 items
  
  (defconstant +release-mode+ nil)
  
  (defmacro def-typed-bag (element-type &body eraser-instance)
    (assert (and (symbolp element-type)
  	       (not (null element-type))
  	       (= (length eraser-instance) 1)))
    (labels ((symb (&rest args) (values (intern (format nil "~{~a~}" args)))))
      (let* ((root-type (symb '%%root-bag-type-for- element-type))
  	   (bag-type (symb '%typed-bag-for- element-type))
  	   (rummager-type (symb element-type '-rummager))
  	   (added-callbacks (symb root-type '-added-callbacks))
  	   (extension (symb root-type '-extension))
  	   (holes-in-items (symb root-type '-holes-in-items))
  	   (item-cache (symb root-type '-item-cache))
  	   (items (symb root-type '-items))
  	   (items-to-cache-indices (symb root-type '-items-to-cache-indices))
  	   (parent (symb root-type '-parent))
  	   (removed-callbacks (symb root-type '-removed-callbacks))
  	   (rummagers (symb bag-type '-rummagers))
  	   (predicate (symb rummager-type '-predicate))
  	   (add-item (symb 'add-item-to- element-type '-bag))
  	   (remove-item (symb 'remove-item-from- element-type '-bag))
  	   (remove-all (symb 'remove-all-from- element-type '-bag))
  	   (eraser (gensym "eraser")))
        `(progn
  	 (defstruct ,root-type
  	   (items
  	    (make-array 0 :element-type '(or ,element-type null) :adjustable t
  			:fill-pointer 0)
  
negative.code: 	    :type (array fixnum (*)))
  	   (holes-in-items nil :type list)
  	   (added-callbacks
  	    (make-array 0 :element-type '(function (,bag-type ,element-type) t)
  			:adjustable t :fill-pointer 0)
  	    :type (array (function (,bag-type ,element-type) t) (*)))
  	   (removed-callbacks
  	    (make-array 0 :element-type '(function (,bag-type ,element-type) t)
  				:adjustable t :fill-pointer 0)
  	    :type (array (function (,bag-type ,element-type) t) (*)))
  	   (extension 100 :type fixnum)
  	   (rummagers (error "rummage array missing")
  		      :type (array %rummager-base (*))))
  
  	 (defstruct (,rummager-type (:include %rummager-base))
  	   (predicate (error "predicate is mandatory to start rummaging")
  		      :type (function (,element-type) boolean))
  	   (bag (error "bag missing") :type ,bag-type)
  	   (parent nil :type (or ,bag-type null)))
  
  	 (defmethod print-object ((object ,bag-type) stream)
  	   (format stream ,(format nil "#<BAG-OF-~s (~~s)>" element-type)
  