anchor.diff:        (let ((root (root (current-owner-node history))))
           (cons root (all-children root))))))
   
  +(export 'owned-root)
   (defun owned-root (owner)
     "Return the first parent among the contiguous owned parents of NODE."
     (first (last (node-contiguous-owned-parents owner (current owner)))))
  
positive.code:                         (mapcar #'traverse (funcall children-function node)))))))
      (let ((root (typecase tree
                    (node tree)
                    (history-tree (root tree)))))
        (when root
          (if include-root
              (traverse root)
              (apply #'append (mapcar #'traverse (children root))))))))
  
  (export-always 'do-tree)
  (defmacro do-tree ((var tree) &body body) ; TODO: Edit? Unexport?
  
negative.code:         (current owner))))
  
  (export-always 'map-tree)
  (defun map-tree (function tree &key flatten include-root
                                   (collect-function #'cons)
                                   (children-function #'children))
    "Map the FUNCTION over the TREE.
  If TREE is a `htree:history-tree', start from its current branch root.
  If TREE is a `htree:node', start from it.
  Include results of applying FUNCTION over ROOT if INCLUDE-ROOT is
  non-nil.
  