anchor.diff:    ((hash
       :reader conflict-hash
       :initarg :hash)
  -   (alist
  -    :reader conflict-alist
  -    :initarg :alist
  +   (entries
  +    :reader conflict-entries
  +    :initarg :entries
       :initform '())))
   
   (defclass table-node ()
  
positive.code: ;; collision. If there is now only 1 key with the given hash, we can
  ;; return a value-node, since there is no longer a collision.
  (defmethod %hamt-remove ((node conflict-node) key hash depth test)
    (let ((alist (alist-remove key (conflict-alist node) test)))
      (let ((len (length alist)))
        (cond
          ;; Can we get rid of this conditional branch? If the length of the
          ;; alist is 0, that means it used to be 1, but we should never have
          ;; had a conflict node with only 1 entry in the first place.
          ((= len 0) nil)
          ((= len 1) (make-instance 'value-node
                                    :key (caar alist)
                                    :value (cdar alist)))
          (t (make-instance 'conflict-node
                            :hash hash
                            :alist alist))))))
  
  ;; Removing a key from a table node can mean updating its bitmap if there
  ;; is nothing left in the corresponding branch.
  
negative.code:                        :value value)
          (make-instance 'conflict-node
                         :hash hash
                         :entries (->> '()
                                       (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 ((entries (conflict-entries node)))
      (make-instance 'conflict-node
                     :hash hash
                     :entries (if (assoc key entries)
                                  (mapcar (lambda (kv)
                                            (if (funcall test (car kv) key)
                                                (cons key value)
                                                (cons (car kv) (cdr kv))))
                                          entries)
                                  (acons key value entries)))))
  
  (defmethod %hamt-insert ((node table-node) key value hash depth test)
    (let* ((bitmap (table-bitmap node))
  