anchor.diff:                      if czx = 0 then
                           AvlDiet.reroot left right
                       else
  -                        AvlTree.Node ((x, pred y), left, right, h)
  +                        Node ((x, pred y), left, right, h)
                   elif czx = 0 then
  -                    AvlTree.Node ((succ x, y), left, right, h)
  +                    Node ((succ x, y), left, right, h)
                   else
  -                    addRange (succ value, y) (AvlTree.Node ((x, pred value), left, right, h))    
  +                    addRange (succ value, y) (Node ((x, pred value), left, right, h))    
   
       /// Computes the union of the two sets.
       let rec union (input : CharDiet) (stream : CharDiet) : CharDiet =
           let rec union' (input : CharDiet) limit head (stream : CharDiet) =
               match head with
               | None ->
  -                input, None, AvlTree.Empty
  +                input, None, Empty
               | Some (x, y) ->
                   match input with
  -                | AvlTree.Empty ->
  -                    AvlTree.Empty, head, stream
  -                | AvlTree.Node ((a, b), left, right, _) ->
  +                | Empty ->
  +                    Empty, head, stream
  +                | Node ((a, b), left, right, _) ->
                       let left', head, stream =
                           if x < a then
                               union' left (Some <| pred a) head stream
  
positive.code:                 elif value > succ y then
                      AvlDiet.join (x, y) left (add value right)
                  elif AvlTree.isEmpty right then
                      AvlTree.Node ((x, value), left, right, h)
                  else
                      let (u, v), r = AvlTree.extractMin right
                      if pred u = value then
                          AvlDiet.join (x, v) left r
                      else
                          AvlTree.Node ((x, value), left, right, h)
  
              elif value < pred x then
                  AvlDiet.join (x, y) (add value left) right
              elif AvlTree.isEmpty left then
                  AvlTree.Node ((value, y), left, right, h)
              else
                  let (u, v), l = AvlTree.extractMax left
                  if succ v = value then
                      AvlDiet.join (u, y) l right
                  else
                      AvlTree.Node ((value, y), left, right, h)
  
      /// Builds a new DIET from the elements of a sequence.
      let ofSeq (sequence : seq<_>) : CharDiet =
  
negative.code:         and diff_helper (a, b) (right : CharDiet) (left : CharDiet) head stream =
              match head with
              | None ->
                  AvlDiet.join (a, b) left right, None, Empty
              | Some (x, y) ->
                  if y < a then
                      // [x, y] and [a, b] are disjoint
  