anchor.diff:    (with-loc loc
       (when (consp loc-tree)
         (list (car loc-tree)
  -            (make-node :left nil
  -                       :ppath loc-path
  -                       :right (cdr 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 (node-left loc-path))
  -            (right (node-right loc-path)))
  +      (let ((left (loc-left loc-path))
  +            (right (loc-right loc-path)))
           (when right
             (list (car right)
  -                (make-node :left (cons loc-tree left)
  -                           :ppath (node-ppath loc-path)
  -                           :right (cdr 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
  -      (node-right 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 (node-right loc-path)))
  +        (let ((right (loc-right loc-path)))
             (list (car (last right))
  -                (make-node :left (cons (car (butlast right)) (list loc-tree))
  -                           :ppath (node-ppath loc-path)
  -                           :right nil)))
  +                (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 (node-left loc-path))
  -             (right (node-right loc-path)))
  +       (let ((left (loc-left loc-path))
  +             (right (loc-right loc-path)))
            (when left
              (list (car left)
  -                 (make-node :left (cdr left)
  -                            :ppath (node-ppath loc-path)
  -                            :right (cons loc-tree right))))))))
  +                 (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
  -      (node-left 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 (node-left loc-path)))
  +        (let ((left (loc-left loc-path)))
             (list (car (last left))
  -                (make-node :left nil
  -                           :ppath (node-ppath loc-path)
  -                           :right (cons (car (butlast left)) (list loc-tree)))))
  +                (make-loc :left nil
  +                          :ppath (loc-ppath loc-path)
  +                          :right (cons (car (butlast left)) (list loc-tree)))))
         loc)))
   
   (defun go-up (loc)
  
positive.code:   (with-loc loc
      (when loc-path
        (list loc-tree
              (make-node :left (cons tree (node-left loc-path))
                         :ppath (node-ppath loc-path)
                         :right (node-right loc-path))))))
  
  (defun insert-down (loc tree)
    "Inserts the item as the leftmost child of the node at this loc, without
  
negative.code: (in-package :cl-zipper)
  
  (defstruct loc
    "A location consists of a distinguished tree, the current focus of attention
  and its path, representing its surrounding context."
    (left "Nodes on the left of this node.")
    (ppath "Path to this node from the root.")
    (right "Nodes on the right of this node."))
  
  (defun zipper (lst)
    "Creates a zipper for the list lst."
  