anchor.diff:      /// Applies the given accumulating function to all the elements of the set.
       [<CompiledName("FoldBack")>]
       let foldBack (folder : char -> 'State -> 'State) tree (state : 'State) =
  +        let folder = FSharpFunc<_,_,_>.Adapt folder
           foldBackImpl folder tree state id
  +
  +    //
  +    let rec private foldIntervalsImpl (folder : FSharpFunc<'State, char, char, 'State>) (state : 'State) tree cont =
  +        match tree with
  +        | Empty ->
  +            cont state
  +        | Node (lowerBound, upperBound, left, right) ->
  +            // Fold over the left subtree
  +            foldIntervalsImpl folder state left <| fun state ->
  +                // Apply the folder function to this interval.
  +                let state = folder.Invoke (state, lowerBound, upperBound)
  +
  +                // Fold over the right subtree
  +                foldIntervalsImpl folder state right cont
  +
  +    /// Applies the given accumulating function to all the intervals of the set.
  +    [<CompiledName("FoldIntervals")>]
  +    let foldIntervals (folder : 'State -> char -> char -> 'State) (state : 'State) tree =
  +        let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +        foldIntervalsImpl folder state tree id
  +
  +    //
  +    let rec private foldBackIntervalsImpl (folder : FSharpFunc<char, char, 'State, 'State>) tree (state : 'State) cont =
  +        match tree with
  +        | Empty ->
  +            cont state
  +        | Node (lowerBound, upperBound, left, right) ->
  +            // Fold backward over the right subtree
  +            foldBackIntervalsImpl folder right state <| fun state ->
  +
  +            // Apply the folder function to this interval.
  +            let state = folder.Invoke (lowerBound, upperBound, state)
  +
  +            // Fold backward over the left subtree
  +            foldBackIntervalsImpl folder left state cont
  +
  +    /// Applies the given accumulating function to all the elements of the set.
  +    [<CompiledName("FoldBackIntervals")>]
  +    let foldBackIntervals (folder : char -> char -> 'State -> 'State) tree (state : 'State) =
  +        let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +        foldBackIntervalsImpl 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")>]
  
positive.code:     /// Applies the given accumulating function to all the elements of the set.
      [<CompiledName("Fold")>]
      let fold (folder : 'State -> char -> 'State) (state : 'State) tree =
          foldImpl folder state tree id
  
      //
      let rec private foldBackImpl (folder : char -> 'State -> 'State) tree (state : 'State) cont =
          match tree with
          | Empty ->
              cont state
  
negative.code:     /// Computes the union of the two sets.
      [<CompiledName("Union")>]
      let union set1 set2 =
          // OPTIMIZE : This could probably be re-implemented to walk both
          // trees at once, building a new set from the bottom up. This would
          // avoid multiple traversals of both set trees and the result set tree.
  
          // TEMP : This works, but it's **slow**.
          let smaller, larger =
  