anchor.diff:                  AvlTree.Create (k, t1, t2)
   
       //
  -    static member Split (comparer : IComparer<'T>, t, pivot) : AvlTree<'T> * bool * AvlTree<'T> =
  -        // Given a pivot and a set t
  -        // Return { x in t s.t. x < pivot }, pivot in t? , { x in t s.t. x > pivot }
  -        match t with
  -        | Empty  ->
  -            Empty, false, Empty
  -        | Node (Empty, Empty, k1, _) ->
  -            let c = comparer.Compare (k1, pivot)
  -            if   c < 0 then t    ,false,Empty // singleton under pivot
  -            elif c = 0 then Empty,true ,Empty // singleton is    pivot
  -            else            Empty,false,t     // singleton over  pivot
  -        | Node (t11, t12, k1, _) ->
  -            let c = comparer.Compare (pivot, k1)
  -            if   c < 0 then // pivot t1
  -                let t11Lo, havePivot, t11Hi = AvlTree.Split (comparer, t11, pivot)
  -                t11Lo, havePivot, AvlTree.Balance (comparer, t11Hi, t12, k1)
  -            elif c = 0 then // pivot is k1
  -                t11,true,t12
  -            else            // pivot t2
  -                let t12Lo, havePivot, t12Hi = AvlTree.Split (comparer, t12, pivot)
  -                AvlTree.Balance (comparer, t11, t12Lo, k1), havePivot, t12Hi
  -
       static member private CompareStacks (comparer : IComparer<'T>, l1 : AvlTree<'T> list, l2 : AvlTree<'T> list) : int =
           match l1, l2 with
           | [], [] -> 0
  
positive.code: 
      /// The set containing the elements in the given range.
      static member FromRange (lowerBound, upperBound) : CharSet =
          CharSet (CharDiet.ofRange lowerBound upperBound)
  
      //
      static member IsEmpty (charSet : CharSet) : bool =
          CharDiet.isEmpty charSet.Tree
  
      /// Returns a new set with an element added to the set.
      /// No exception is raised if the set already contains the given element.
      static member Add (value, charSet : CharSet) : CharSet =
          CharSet (CharDiet.add value charSet.Tree)
  
      //
      static member AddRange (lower, upper, charSet : CharSet) : CharSet =
          CharSet (CharDiet.addRange (lower, upper) charSet.Tree)
  
      //
      static member Remove (value, charSet : CharSet) : CharSet =
          CharSet (CharDiet.remove value charSet.Tree)
  
      //
      static member Contains (value, charSet : CharSet) : bool =
          CharDiet.contains value charSet.Tree
  
      //
      static member OfSeq (sequence : seq<char>) : CharSet =
          CharSet (CharDiet.ofSeq sequence)
  
      //
      static member OfList (list : char list) : CharSet =
          CharSet (CharDiet.ofList list)
  
      //
      static member OfArray (array : char[]) : CharSet =
          CharSet (CharDiet.ofArray array)
  
      //
      static member OfSet (set : Set<char>) : CharSet =
          CharSet (CharDiet.ofSet set)
  
      //
      static member ToSeq (charSet : CharSet) : seq<char> =
          CharDiet.toSeq charSet.Tree
  
      //
      static member ToList (charSet : CharSet) : char list =
          CharDiet.toList charSet.Tree
  
      //
      static member ToArray (charSet : CharSet) : char[] =
          CharDiet.toArray charSet.Tree
  
      //
      static member ToSet (charSet : CharSet) : Set<char> =
          CharDiet.toSet charSet.Tree
  
      //
      static member Difference (charSet1 : CharSet, charSet2 : CharSet) : CharSet =
          CharSet (CharDiet.difference charSet1.Tree charSet2.Tree)
  
      //
      static member Intersect (charSet1 : CharSet, charSet2 : CharSet) : CharSet =
          CharSet (CharDiet.intersect charSet1.Tree charSet2.Tree)
  
      //
      static member Union (charSet1 : CharSet, charSet2 : CharSet) : CharSet =
          CharSet (CharDiet.union charSet1.Tree charSet2.Tree)
  
      //
      static member Exists (predicate, charSet : CharSet) : bool =
          CharDiet.exists predicate charSet.Tree
  
      //
      static member Forall (predicate, charSet : CharSet) : bool =
          CharDiet.forall predicate charSet.Tree
  
      //
      static member Fold (folder : 'State -> _ -> 'State, state, charSet : CharSet) : 'State =
          CharDiet.fold folder state charSet.Tree
  
      //
      static member FoldBack (folder : _ -> 'State -> 'State, state, charSet : CharSet) : 'State =
          CharDiet.foldBack folder charSet.Tree state
  
      //
      static member Iter (action, charSet : CharSet) : unit =
          CharDiet.iter action charSet.Tree
  
      //
      static member IterIntervals (action, charSet : CharSet) : unit =
          let action = FSharpFunc<_,_,_>.Adapt action
          charSet.Tree |> AvlTree.Iter action.Invoke
  
      //
      static member Map (mapping : char -> char, charSet : CharSet) : CharSet =
          notImpl "CharSet.Map"
  
      //
      static member Filter (predicate : char -> bool, charSet : CharSet) : CharSet =
          notImpl "CharSet.Filter"
  
      //
      static member Partition (predicate : char -> bool, charSet : CharSet) : CharSet * CharSet =
          notImpl "CharSet.Partition"
  
      interface System.IComparable with
  
negative.code:         (Set.empty, tree)
          ||> fold (fun set el ->
              Set.add el set)
  
  
  /// Character set implementation based on a Discrete Interval Encoding Tree.
  