anchor.diff:                  thisCount + leftCount + rightCount
                   |> cont
   
  -    //
  +    /// Returns the number of elements in the set.
       [<CompiledName("Count")>]
       let count tree =
           countImpl tree id
  
positive.code:         ||> Set.fold (fun tree el ->
              add el tree)
  
      //
      [<CompiledName("ToArray")>]
      let toArray tree =
          let resizeArr = ResizeArray<_> ()
          iter resizeArr.Add tree
          resizeArr.ToArray ()
  
      //
      [<CompiledName("OfArray")>]
      let ofArray array =
          (empty, array)
          ||> Array.fold (fun tree el ->
              add el tree)
  
      //
      [<CompiledName("ToSeq")>]
      let rec toSeq tree =
          seq {
  
negative.code:             // Fold backward over the left subtree
              foldBackImpl folder left state cont
  
      /// Applies the given accumulating function to all the elements of the set.
      [<CompiledName("FoldBack")>]
      let foldBack (folder : char -> 'State -> 'State) tree (state : 'State) =
          foldBackImpl folder tree state id
  
      /// Returns a new set containing the results of applying the given function to each element of the input set.
      [<CompiledName("Map")>]
      let map (mapping : char -> char) tree =
          (empty, tree)
          ||> fold (fun set el ->
              add (mapping el) set)
  
      /// Returns a new set containing only the elements of the collection for which the given predicate returns true.
      [<CompiledName("Filter")>]
      let filter (predicate : char -> bool) tree =
          (empty, tree)
          ||> fold (fun set el ->
              if predicate el then
                  add el set
              else set)
  
      //
      let rec private iterImpl (action : char -> unit) tree cont =
  