anchor.diff:              elif AvlTree.isEmpty left then
                   AvlTree.Node ((p, y), left, right, h)
               else
  -                let (u, v), l = AvlTree.extractMax charComparer left
  +                let (u, v), l = AvlTree.extractMax left
                   if (succ v) = p then
                       AvlDiet.join (u, y) l right
                   else
  
positive.code:             | Some (x, y) ->
                  if compare y a < 0 then
                      // [x, y] and [a, b] are disjoint
                      let head, stream = AvlTree.tryExtractMin charComparer stream
                      diff_helper (a, b) right left head stream
                  elif compare b x < 0 then
                      // [a, b] and [x, y] are disjoint
  
negative.code:         if tree1_count < tree2_count then
              (tree2, tree1)
              ||> fold (fun tree el ->
                  insert el tree)
          else
              (tree1, tree2)
              ||> fold (fun tree el ->
                  insert el tree)
  
      /// Builds a new AVL tree from the elements of a sequence.
      let ofSeq (sequence : seq<_>) : AvlTree<'T> =
          (Empty, sequence)
          ||> Seq.fold (fun tree el ->
              insert el tree)
  
      /// Builds a new AVL tree from the elements of an F# list.
      let ofList (list : _ list) : AvlTree<'T> =
          (Empty, list)
          ||> List.fold (fun tree el ->
              insert el tree)
  
      /// Builds a new AVL tree from the elements of an array.
      let ofArray (array : _[]) : AvlTree<'T> =
          (Empty, array)
          ||> Array.fold (fun tree el ->
              insert el tree)
  
      /// Returns a sequence containing the elements stored
      /// in an AVL tree, ordered from least to greatest.
  