anchor.diff:    "Return the OWNER's owned children for the current node."
     (funcall (owned-children-lister owner) (current owner) ))
   
  -(defun owned-parent (owner)
  +(defun owned-parent (owner)             ; TODO: Unused.  Generalize for `history-tree'?
     "Return OWNER's parent if it's owned, nil otherwise."
     (let ((parent (parent (current owner))))
       (when (gethash owner (bindings parent))
  
positive.code:   (:accessor-name-transformer #'class*:name-identity)
    (:documentation "Wrapped data as stored in `history-tree''s `entries'."))
  
  (defun make-entry (history data)        ; Flet in `add-entry'?
    "Return an `entry' wrapping DATA and suitable for HISTORY."
    (make-instance 'entry :value data
                          :key (key history)
  
negative.code: 
  (define-class node ()
    ((parent nil
             :type (or null node)
             :documentation "If nil, it means the node is a root node.")
     (children '()
               :documentation "List of nodes.
  Order does not matter.")
     (bindings (make-hash-table)
               :documentation "The key is an `owner', the value is a
  `binding'.  This slot also allows us to know to which owner a node belongs.")
     (entry (error "Entry required")
            :type entry
            :documentation "Arbitrary data (wrapped in an `entry' object) carried
  by the node.  `history-tree''s `entries' holds `entry'-`node' associations."))
    (:export-class-name-p t)
    (:export-accessor-names-p t)
    (:accessor-name-transformer #'class*:name-identity)
    (:documentation "Node structure of the history tree."))
  
  (export 'value)
  (defmethod value ((node node))
  