anchor.diff:  depth-first walk."
     (with-loc loc
       (when (and loc loc-path)
  -      (cond ((node-right loc-path) (replace-by-right loc-path))
  -            ((node-left loc-path) (replace-by-left loc-path))))))
  +      (cond ((loc-right loc-path) (replace-by-right loc-path))
  +            ((loc-left loc-path) (replace-by-left loc-path))))))
   
   (defun replace-by-right (loc-path)
     "Replaces the current node at loc by the node at the right."
     (when loc-path
  -    (let ((right (node-right loc-path)))
  +    (let ((right (loc-right loc-path)))
         (list (car right)
  -            (make-node :left (node-left loc-path)
  -                       :ppath (node-ppath loc-path)
  -                       :right (cdr right))))))
  +            (make-loc :left (loc-left loc-path)
  +                      :ppath (loc-ppath loc-path)
  +                      :right (cdr right))))))
   
   (defun replace-by-left (loc-path)
     "Replaces the current node at loc by the node at the left."
     (when loc-path
  -    (let ((left (node-left loc-path)))
  +    (let ((left (loc-left loc-path)))
         (list (car left)
  -            (make-node :left (cdr left)
  -                       :ppath (node-ppath loc-path)
  -                       :right (node-right loc-path))))))+            (make-loc :left (cdr left)
  +                      :ppath (loc-ppath loc-path)
  +                      :right (loc-right loc-path))))))
  
positive.code:   (with-loc loc
      (when loc-path
        (list loc-tree
              (make-node :left (node-left loc-path)
                         :ppath (node-ppath loc-path)
                         :right (cons tree (node-right loc-path)))))))
  
  (defun insert-left (loc tree)
    "Inserts the item as the left sibling of the node at this loc, without
  
negative.code:   (with-loc loc
      (when (consp loc-tree)
        (list (car loc-tree)
              (make-loc :left nil
                        :ppath loc-path
                        :right (cdr loc-tree))))))
  
  (defun go-right (loc)
    "Returns the loc of the right sibling of the node at this loc, or nil."
    (with-loc loc
      (when loc-path
        (let ((left (loc-left loc-path))
              (right (loc-right loc-path)))
          (when right
            (list (car right)
                  (make-loc :left (cons loc-tree left)
                            :ppath (loc-ppath loc-path)
                            :right (cdr right))))))))
  
  (defun rights (loc)
    "Returns a list of the right siblings of this loc."
    (with-loc loc
      (when loc-path
        (loc-right loc-path))))
  
  (defun rightmost (loc)
    "Returns the loc of the rightmost sibling of the node at this loc, or self."
    (with-loc loc
      (if loc-path
          (let ((right (loc-right loc-path)))
            (list (car (last right))
                  (make-loc :left (cons (car (butlast right)) (list loc-tree))
                            :ppath (loc-ppath loc-path)
                            :right nil)))
        loc)))
  
  (defun go-left (loc)
    "Returns the loc of the left sibling of the node at this loc, or nil."
    (with-loc loc
       (when loc-path
         (let ((left (loc-left loc-path))
               (right (loc-right loc-path)))
           (when left
             (list (car left)
                   (make-loc :left (cdr left)
                             :ppath (loc-ppath loc-path)
                             :right (cons loc-tree right))))))))
  
  (defun lefts (loc)
    "Returns a list of the left siblings of this loc."
    (with-loc loc
      (when loc-path
        (loc-left loc-path))))
  
  (defun leftmost (loc)
    "Returns the loc of the leftmost sibling of the node at this loc, or self."
    (with-loc loc
      (if loc-path
          (let ((left (loc-left loc-path)))
            (list (car (last left))
                  (make-loc :left nil
                            :ppath (loc-ppath loc-path)
                            :right (cons (car (butlast left)) (list loc-tree)))))
        loc)))
  
  (defun go-up (loc)
  