anchor.diff:  (export-always 'map-owned-tree)
   (defun map-owned-tree (function tree &key flatten include-root
                                          (collect-function #'cons)
  -                                       (owner (if (history-tree-p tree)
  -                                                  (current-owner tree)
  -                                                  (current-owner (history (entry tree))))))
  +                                       owner)
     "Like `map-tree' but restrict traversal to OWNER's nodes."
     (map-tree function (if (history-tree-p tree)
                            (owned-root owner)
  
positive.code:    (current owner)))
  
  (export 'all-contiguous-owned-nodes)
  (defmethod all-contiguous-owned-nodes ((history history-tree))
    "Return a list of all nodes contiguous to the current owner node, starting
  from the top-most parent, in depth-first order."
    (let ((owned-root (owned-root (current-owner history))))
      (when owned-root
        (cons owned-root (all-contiguous-owned-children history owned-root)))))
  
  (export-always 'all-data)
  (defmethod all-data ((history history-tree))
  
negative.code:     (contiguous-owned-parents node)))
  
  (export-always 'all-contiguous-owned-parents)
  (defmethod all-contiguous-owned-parents ((history history-tree) owner-spec)
    "Return a list of parents of owned by HISTORY OWNER-SPEC current node, recursively.
  First parent comes first in the resulting list."
    (alex:when-let ((owner (owner history owner-spec)))
      (node-contiguous-owned-parents owner
                                     (current owner))))
  
  (export-always 'all-forward-children)
  (defmethod all-forward-children ((history history-tree)
                                   owner-spec
                                   &optional (node (owner-node history owner-spec)))
    "Return a list of the forward children of NODE, recursively.
  First child comes first in the resulting list."
    (alex:when-let ((owner (owner history owner-spec)))
      (let ((binding (current-binding owner node)))
        (when (and binding (forward-child binding))
          (cons (forward-child binding)
                (all-forward-children history
                                      owner-spec
                                      (forward-child binding)))))))
  
  (export 'all-owner-nodes)
  (defmethod all-owner-nodes ((history history-tree) owner-spec)
    "Return a list of all OWNER nodes, in unspecified order."
    (alex:when-let ((owner (owner history owner-spec)))
      (nodes owner)))
  
  (export 'all-branch-nodes)
  (defmethod all-branch-nodes ((history history-tree) owner-spec)
    "Return a list of all nodes that belong to the branch OWNER-SPEC node is on.
  These nodes do not necessarily belong to OWNER-SPEC.
  See `all-contiguous-owned-nodes'."
    (alex:when-let ((node (owner-node history owner-spec)))
      (let ((root (root node)))
        (cons root (all-children root)))))
  
  (export 'owned-root)
  (defun owned-root (owner)
  