anchor.diff:      (cond
         ((null (current owner))
          (let ((new-node (make-node :entry (add-entry history data)
  -                                  :parent (creator-node owner)
  -                                  :history history)))
  +                                  :parent (creator-node owner))))
            (when (creator-node owner)
              (push new-node (children (creator-node owner))))
            (setf (origin owner) new-node)
  
positive.code: We allow null values for easier deserialization.")
     (value nil
            :type t
            :documentation "Arbitrary data."))
    (:accessor-name-transformer #'class*:name-identity)
    (:export-accessor-names-p t)
    (:documentation "Wrapped data as stored in `history-tree''s `entries'."))
  
negative.code:         (forward history (1- count))))
      (values history (current owner))))
  
  (defun find-entry (history data)
    "Return the nodes matching DATA."
    (cl-custom-hash-table:with-custom-hash-table
      (let ((new-entry (make-entry history data)))
        (gethash new-entry (entries history)))))
  
  (export 'find-nodes)
  (defun find-nodes (history data)
    "Return the nodes matching DATA."
    (cl-custom-hash-table:with-custom-hash-table
      (let ((entry (find-entry history data)))
        (when entry
          (nodes entry)))))
  
  (declaim (ftype (function (t owner) (or null node)) find-child))
  (defun find-child (data owner) ; TODO: Generalize?
  