anchor.diff:    (when (current-owner history)
       (all-parents (current-owner-node history))))
   
  -(export-always 'all-owned-parents)
  -(defmethod all-owned-parents ((owner owner))
  +(export-always 'all-contiguous-owned-parents)
  +(defmethod all-contiguous-owned-parents ((owner owner))
     "Return a list of parents of owned by OWNER, starting from its current node,
   recursively.
   First parent comes first in the resulting list."
     (when (and (parent owner)
                (owned-p owned (parent owner)))
       (cons (parent owner)
  -          (all-owned-parents (current owner)))))
  -
  -(defmethod all-owned-parents ((history history))
  +          (all-contiguous-owned-parents (current owner)))))
  +
  +(defmethod all-contiguous-owned-parents ((history history))
     "Return a list of parents of owned by HISTORY current owner, starting from its
   current node, recursively.  First parent comes first in the resulting list."
     (when (current-owner history)
  -    (all-owned-parents (current-owner history))))
  +    (all-contiguous-owned-parents (current-owner history))))
   
   (export-always 'all-forward-children)
   (defmethod all-forward-children ((owner owner))
  
positive.code:   (when (current-owner history)
      (all-children (current-owner-node history))))
  
  (export-always 'all-owned-children)
  (defmethod all-owned-children ((owner owner))
    "Return a list of all the children owned by OWNER, recursively."
    (map-tree #'identity (current owner) :flatten t
                                         :children-function #'owned-children))
  
  (defmethod all-owned-children ((history history))
    "Return a list of all the children owned by HISTORY's current owner,
  recursively."
    (when (current-owner history)
      (all-owned-children (current-owner history))))
  
  (export-always 'all-parents)
  (defmethod all-parents ((node node))
  
negative.code:     (when root
        (cons root (all-children root)))))
  
  (defmethod all-nodes ((owner owner))
    "Return a list of all OWNER nodes, in no particular order."
    (nodes owner))
  
  (export 'all-contiguous-owned-nodes)
  (defmethod all-contiguous-owned-nodes ((owner owner))
    "Return a list of all owner nodes, in depth-first order."
    (let ((owner-root (first (all-contiguous-owned-parents owner))))
      (when owner-root
        (cons owner-root (all-contiguous-owned-children owner-root)))))
  
  
  
  