anchor.diff:                  x, left
   
       //
  -    let rec private find_del_right p (tree : CharDiet) =
  +    let rec internal (*private*) find_del_right p (tree : CharDiet) : char * CharDiet =
           match tree with
           | Empty ->
               p, Empty
  
positive.code:                 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
  
negative.code:             #endif
              result
  
      /// Applies the given accumulating function to all elements in a DIET.
      let fold (folder : 'State -> char -> 'State) (state : 'State) (tree : CharDiet) =
          // Preconditions
  