anchor.diff:  
       //
       static member OfList list =
  -        CharSet (Diet.ofList charMeasurer list)
  +        CharSet (Diet.ofList list)
   
   //    //
   //    static member ToSet (charSet : CharSet) =
  
positive.code:             result
  
      /// Computes the intersection of the two sets.
      let rec intersect (measurer : IMeasurer<_>) (input : Diet<'T>) (stream : Diet<'T>) : Diet<'T> =
          let inline compare a b =
              measurer.Compare (a, b)
  
          let rec inter' (input : Diet<_>) head (stream : Diet<_>) =
              match head with
              | None ->
                  AvlTree.Empty, None, AvlTree.Empty
              | Some (rangeXY : Range<_>) ->
                  match input with
                  | AvlTree.Empty ->
                      AvlTree.Empty, head, stream
                  | AvlTree.Node (rangeAB, left, right, _) ->
                      let left, head, stream =
                          if compare rangeXY.MinValue rangeAB.MinValue < 0 then
                              inter' left head stream
                          else
                              AvlTree.Empty, head, stream
                      inter_help rangeAB right left head stream
  
          and inter_help (rangeAB : Range<_>) (right : Diet<_>) (left : Diet<_>) head stream =
              match head with
              | None ->
                  left, None, AvlTree.Empty
              | Some (rangeXY : Range<_>) ->
                  if compare rangeXY.MaxValue rangeAB.MinValue < 0 then
                      if AvlTree.isEmpty stream then
                          (left, None, AvlTree.Empty)
                      else
                          let head, stream = AvlTree.extractMin measurer stream
                          inter_help rangeAB right left (Some head) stream
                  elif compare rangeAB.MaxValue rangeXY.MinValue < 0 then
                      let right, head, stream = inter' right head stream
                      AvlTree.reroot measurer left right, head, stream
                  elif compare rangeXY.MaxValue (safe_pred measurer rangeXY.MaxValue rangeAB.MaxValue) >= 0 then
                      let (right, head, stream) = inter' right head stream
                      let newRange = Range (max measurer rangeXY.MinValue rangeAB.MinValue, min measurer rangeXY.MaxValue rangeAB.MaxValue)
                      ((AvlTree.join newRange left right), head, stream)
                  else
                      let left =
                          let newRange = Range (max measurer rangeXY.MinValue rangeAB.MinValue, rangeXY.MaxValue)
                          addRange measurer newRange left
                      let newRange = Range (measurer.Next rangeXY.MaxValue, rangeAB.MaxValue)
                      inter_help newRange right left head stream
  
          if AvlTree.height stream > AvlTree.height input then
              intersect measurer stream input
          elif AvlTree.isEmpty stream then
              AvlTree.Empty
          else
              let head, stream = AvlTree.extractMin measurer stream
              let result, _, _ = inter' input (Some head) stream
              result
  
      /// Returns a new set with the elements of the second set removed from the first.
      let difference (measurer : IMeasurer<_>) (input : Diet<'T>) (stream : Diet<'T>) : Diet<'T> =
          let inline compare a b =
              measurer.Compare (a, b)
  
          let rec diff' input head stream =
              match head with
              | None ->
                  input, None, AvlTree.Empty
              | Some (rangeXY : Range<_>) ->
                  match input with
                  | AvlTree.Empty ->
                      (AvlTree.Empty, head, stream)
                  | AvlTree.Node (rangeAB : Range<_>, left, right, _) ->
                      let left, head, stream =
                          if compare rangeXY.MinValue rangeAB.MinValue < 0 then
                              diff' left head stream
                          else
                              left, head, stream
                      diff_helper rangeAB right left head stream
  
          and diff_helper (rangeAB : Range<_>) (right : Diet<_>) (left : Diet<_>) head stream =
              match head with
              | None ->
                  AvlTree.join rangeAB left right,
                  None,
                  AvlTree.Empty
              | Some (rangeXY : Range<_>) ->
                  if compare rangeXY.MaxValue rangeAB.MinValue < 0 then
                      // [x, y] and [a, b] are disjoint
                      let head, stream = AvlTree.tryExtractMin measurer stream
                      diff_helper rangeAB right left head stream
                  elif compare rangeAB.MaxValue rangeXY.MinValue < 0 then
                      // [a, b] and [x, y] are disjoint
                      let (right, head, stream) = diff' right head stream
                      (AvlTree.join rangeAB left right, head, stream)
                  elif compare rangeAB.MinValue rangeXY.MinValue < 0 then
                      // [a, b] and [x, y] overlap
                      // a < x
                      let rangeXB = Range (rangeXY.MinValue, rangeAB.MaxValue)
                      let newRange = Range (rangeAB.MinValue, measurer.Previous rangeXY.MinValue)
                      let newLeft = addRange measurer newRange left
                      diff_helper rangeXB right newLeft head stream
                  elif compare rangeXY.MaxValue rangeAB.MaxValue < 0 then
                      // [a, b] and [x, y] overlap
                      // y < b
                      let (head, stream) = AvlTree.tryExtractMin measurer stream
                      let newRange = Range (measurer.Next rangeXY.MaxValue, rangeAB.MaxValue)
                      diff_helper newRange right left head stream
                  else
                      // [a, b] and [x, y] overlap
                      let (right, head, stream) = diff' right head stream
                      (AvlTree.reroot measurer left right, head, stream)
          
          if AvlTree.isEmpty stream then
              input
  
negative.code: 
  //    //
  //    static member OfSet set =
  //        CharSet (Diet.ofSet set)
  
  //    //
  //    static member ToArray (charSet : CharSet) =
  