anchor.diff:                   (f (cdr alist)
                       (funcall func r (caar alist) (cdar alist)))
                    r)))
  -    (f (conflict-alist node) initial-value)))
  +    (f (conflict-entries node) initial-value)))
   
   (defmethod dict-reduce (func (node table-node) initial-value)
     (reduce (lambda (r child)
  
positive.code:                        :value value)
          (make-instance 'conflict-node
                         :hash hash
                         :alist (->> '()
                                     (acons key value)
                                     (acons nkey (node-value node)))))))
  
  ;; Inserting into a conflict node either updates the value associated to an
  ;; existing key, or expands the scope of the conflict
  (defmethod %hamt-insert ((node conflict-node) key value hash depth test)
    (let ((alist (conflict-alist node)))
      (make-instance 'conflict-node
                     :hash hash
                     :alist (if (assoc key alist)
                                (mapcar (lambda (kv)
                                          (if (funcall test (car kv) key)
                                              (cons key value)
                                              (cons (car kv) (cdr kv))))
                                        alist)
                                (acons key value alist)))))
  
  (defmethod %hamt-insert ((node table-node) key value hash depth test)
    (let* ((bitmap (table-bitmap node))
  
negative.code:   ((hash
      :reader conflict-hash
      :initarg :hash)
     (entries
      :reader conflict-entries
      :initarg :entries
      :initform '())))
  
  (defclass table-node ()
  