anchor.diff:                 (avl-tree-concatenate i-left i-right)))))))
   
   (defun avl-tree-difference (tree-1 tree-2 compare)
  +  (declare (type function compare))
     (cond
       ((null tree-1) nil)
       ((null tree-2) tree-1)
  
positive.code:                       (avl-tree-value tree)
                        (avl-tree-remove (avl-tree-right tree) x compare))))
  
  ;; (defun avl-tree-split-less (tree x compare)
  ;;   "Everything in tree before than x"
  ;;   (cond-avl-tree-compare (x tree compare)
  ;;     nil
  ;;     (avl-tree-split-less (binary-tree-left tree) x compare)
  ;;     (binary-tree-left tree)
  ;;     (balance-avl-tree (binary-tree-left tree)
  ;;                       (binary-tree-value tree)
  ;;                       (avl-tree-split-less (binary-tree-right tree) x compare))))
  
  
  ;; (defun avl-tree-split-greater (tree x compare)
  ;;   "Everything in tree after than x"
  ;;   (cond-avl-tree-compare (x tree compare)
  ;;     nil
  ;;     (balance-avl-tree (avl-tree-split-greater (binary-tree-left tree) x compare)
  ;;                       (binary-tree-value tree)
  ;;                       (binary-tree-right tree))
  ;;     (binary-tree-right tree)
  ;;     (avl-tree-split-greater (binary-tree-left tree) x compare)))
  
  
  ;; (defun avl-tree-trim (tree lo hi compare)
  ;;   "Gather all values of TREE between LO and HI."
  ;;   (print tree)
  ;;   (if (null tree)
  ;;       nil
  ;;       (with-avl-tree ((left value right) tree)
  ;;         (if (< (funcall compare lo value) 0)
  ;;             (if (< (funcall compare value hi) 0)
  ;;                 tree
  ;;                 (avl-tree-trim left lo hi compare))
  ;;             (avl-tree-trim right lo hi compare)))))
  
  
  ;; (defun avl-tree-uni-bd (tree-1 tree-2 lo hi compare)
  ;;   (cond
  ;;     ((null tree-1) tree-2)
  ;;     ((null tree-2)
  ;;      (multiple-value-bind (left p right) (avl-tree-split-greater
  ;;                                           (
  
  
  ;; (defun avl-tree-hedge-union (tree-1 tree-1)
  ;;   (cond
  ;;     ((null tree-1) tree-2)
  ;;     ((null tree-2) tree-1)
  
  
  (defun avl-tree-union (tree-1 tree-2 compare)
    (cond
      ((null tree-1) tree-2)
      ((null tree-2) tree-1)
  
negative.code:         ;;(t (error "Unbalanceble tree: ~A ~A" left right))))))
  
  
  (defmacro with-avl-tree((left value right) tree &body body)
    (alexandria:with-gensyms (tree-sym)
      `(let ((,tree-sym ,tree))
         (let ((,left (binary-tree-left ,tree-sym))
  