anchor.diff:  
               else
                   let right', head, stream = union' right limit (Some (min a x, y)) stream
  -                (tapInvariant <| CharDiet.Reroot (comparer, left, right')), head, stream
  +                (tap (fun x -> assert (dietInvariant x)) <| CharDiet.Reroot (comparer, left, right')), head, stream
   
       /// Computes the union of the two sets.
       let rec union (input : CharDiet) (stream : CharDiet) : CharDiet =
  
positive.code:         match tree with
          | Empty ->
              singleton value
              |> tapInvariant
          | Node (left, right, (x, y), h) ->
              if value >= x then
                  if value <= y then
                      // The value is already in [x, y] so the tree
                      // does not need to be modified.
                      tree
                      |> tapInvariant
                  elif value > succ y then
                      // The value is above the interval and is not adjacent
                      // to it, so recurse down the right subtree to add the value
                      // then join the result with the left subtree.
                      CharDiet.Join (comparer, left, add value right, (x, y))
                      |> tapInvariant
                  else
                      match right with
                      | Empty ->
                          CharDiet.Create ((x, value), left, Empty)
                          |> tapInvariant
                      | _ ->
                          let (u, v), r = CharDiet.DeleteMin right
                          if pred u = value then
                              CharDiet.Join (comparer, left, r, (x, v))
                              |> tapInvariant
                          else
                              CharDiet.Create ((x, value), left, right)
                              |> tapInvariant
  
              elif value < pred x then
                  CharDiet.Join (comparer, add value left, right, (x, y))
                  |> tapInvariant
              else
                  match left with
                  | Empty ->
                      CharDiet.Create ((value, y), Empty, right)
                      |> tapInvariant
                  | _ ->
                      let (u, v), l = CharDiet.DeleteMax left
                      if succ v = value then
                          CharDiet.Join (comparer, l, right, (u, y))
                          |> tapInvariant
                      else
                          CharDiet.Create ((value, y), left, right)
                          |> tapInvariant
  
      /// Returns a new set with the specified range of values added to the set.
      /// No exception is thrown if any of the values are already contained in the set.
  
negative.code:             if p > succ y then
                  let p', right' = find_del_left p right
                  assert (dietInvariant right')
                  p', tap (fun x -> assert (dietInvariant x)) <| CharDiet.Join (comparer, left, right', (x, y))
              elif p < x then
                  find_del_left p left
              else
  