anchor.diff:  (defun make-entry (history data)
     "Return an `entry' wrapping DATA and suitable for HISTORY."
     (make-instance 'entry :value data
  -                        :key (key history)
  -                        :test (test history)
  -                        :hash-function (hash-function history)))
  +                        :history history))
   
   (define-class node ()
     ((parent nil
  
positive.code:   (remhash owner (bindings node)))
  
  (defun entry-equal-p (a b)
    (funcall (test a)                     ; `test' of A and B should be the same.
             (funcall (key a) (value a))
             (funcall (key b) (value b))))
  
  (defun entry-hash (a)
    (funcall (hash-function a) (funcall (key a) (value a))))
  
  (cl-custom-hash-table:define-custom-hash-table-constructor make-entry-hash-table
    :test entry-equal-p
    :hash-function entry-hash)
  
  (defun data-equal-entry-p (data entry)
    (funcall (test entry)
             (funcall (key entry) (value entry))
             (funcall (key entry) data)))
  
  (export-always 'add-entry)
  (defun add-entry (history data)
  
negative.code: 
  ;; TODO: Store data-last-access in entry (max of all last-accesses) so that we
  ;; keep this information even for node-less entries.
  (define-class entry ()
    ((history nil
              :type (or null history-tree)
              :documentation "Required.
  This is gives access to the custom hash functions, see the corresponding
  `history-tree' slots.
  We allow null values for easier deserialization.")
     (value nil
            :type t
            :documentation "Arbitrary data."))
  