anchor.diff:  ;; TODO: Store child sets
   ;;       Prevent orphaned frames
   
  +
   (defun tf-tree-frame-compare (a b)
     (if (null a)
         (if (null b)
  
positive.code:                                     (assert (equal frame (tf-tag-child rel-tf)))
                                      (rec absolute-tree frame))
                                    (make-tf-tree)
                                    relative-tree)))))
  
  (defun tf-tree-absolute-tf (relative-tree frame)
    "Compute the absolute transform of FRAME."
  
negative.code:           1
            (sycamore-util:string-compare a b))))
  
  (defstruct (tf-tree (:constructor %make-tf-tree))
    (relative-map (sycamore:make-tree-map #'tf-tree-frame-compare)
                  :type sycamore::tree-map)
    (frame-set( sycamore:make-tree-set #'tf-tree-frame-compare)
              :type sycamore::tree-set))
  
  (defun make-tf-tree ()
    "Create a new TF tree.
  The tree is a map from the frame name to its relative transform."
    (%make-tf-tree :relative-map (sycamore:make-tree-map #'tf-tree-frame-compare)
                   :frame-set (sycamore:make-tree-set #'sycamore-util:string-compare)))
  
  (defun tf-tree-split-insert (tree parent tf child)
    "Add tagged TF to tree."
    (let ((frame-set (tf-tree-frame-set tree)))
      ;; Intern parent and child
      (when parent
        (multiple-value-setq (frame-set parent)
          (sycamore:tree-set-intern frame-set parent)))
      (when child
        (multiple-value-setq (frame-set child)
          (sycamore:tree-set-intern frame-set child)))
      ;; Insert
      (%make-tf-tree :relative-map (sycamore:tree-map-insert (tf-tree-relative-map tree)
                                                             child (tf-tag parent tf child))
                     :frame-set frame-set)))
  
  (defun tf-tree-insert (tree tf-tag)
    "Add tagged TF to tree."
    (tf-tree-split-insert tree
                          (tf-tag-parent tf-tag)
                          (tf-tag-tf tf-tag)
                          (tf-tag-child tf-tag)))
  
  (defun tf-tree-remove (tree frame)
    "Remove FRAME from tree"
    (%make-tf-tree :relative-map (sycamore:tree-map-remove (tf-tree-relative-map tree) frame)
                   :frame-set (sycamore:tree-set-remove (tf-tree-frame-set tree) frame)))
  
  (defun tf-tree-find (tree frame)
    "Find the TF in the tree"
    (let ((tf (sycamore:tree-map-find (tf-tree-relative-map tree) frame)))
      (when tf (assert (equal frame (tf-tag-child tf))))
      tf))
  
  (defun tf-tree-absolute-map (relative-tree &optional frame)
    "Compute the absolute transforms."
  