anchor.diff:              |> (fun (kFrom, kTo, v, xs) -> {KeyFrom = kFrom; KeyTo = kTo; Value = v} :: xs)
               |> ImmutableArray.CreateRange
               |> RangeMap
  -        | None -> empty()
  +        else
  +            empty
   
       let inline ofSeq xs = ofSeqEx ((+) LanguagePrimitives.GenericOne) xs
   
  
positive.code:     /// The keys can be of any type that can has the notion of "one" and equality checking.
      /// The keys have to be sorted beforehand, or the resulting `RangeMap` will be broken.
      let ofSeqEx fSuccessor xs =
          match Seq.tryLast xs with
          | Some(KeyValue(k, v)) ->
              Seq.foldBack (fun (KeyValue(k', v')) (kFrom, kTo, v, xs) ->
                  if v = v' && kFrom = fSuccessor k' then
                      (k', kTo, v, xs)
  
negative.code: /// A map data structure that works best when a continuous range of keys is assigned the same value.
  /// It can also double as a set, when the value type is a unit.
  type RangeMap<'key,'a when 'key :> IComparable<'key>> = private RangeMap of RangeMapElement<'key,'a> ImmutableArray
  
  /// Functions to create and use `RangeMap`s.
  module RangeMap =
  
      /// An empty `RangeMap`.
      [<CompiledName("Empty")>]
      let empty<'key, 'a when 'key :> IComparable<'key>> : RangeMap<'key, 'a> =
          RangeMap ImmutableArray.Empty
  
      /// Looks up an element in a `RangeMap`, returning its corresponding value if it exists.
      [<CompiledName("TryFind")>]
  