anchor.diff:      let tryFind k (RangeMap arr) =
           let idx =
               // .NET's binary search function returns special integer values depending on the outcome.
  -            match Array.BinarySearch(arr, Singleton (k, Unchecked.defaultof<_>)) with
  +            match Array.BinarySearch(arr, (k, k, Unchecked.defaultof<_>), secondComparer) with
               // If it is positive, then an exact element was found in the array.
               | x when x >= 0 -> x
               // If it is the bitwise complement of the array's length, the requested element
  
positive.code: 
  open Farkle
  open System
  
  [<Struct; CustomEquality; CustomComparison>]
  type internal RangePoint<'key,'a when 'key: comparison and 'key: equality> =
      | RangeInclusive of from:'key * _to:'key * value:'a
      | Singleton of key2:'key * value2:'a
      member x.Key =
          match x with
          | RangeInclusive (_, x, _)
          | Singleton (x, _) -> x
      interface IEquatable<RangePoint<'key,'a>> with
          member x.Equals(y) = x.Key = y.Key
      interface IComparable<RangePoint<'key,'a>> with
          member x.CompareTo(y) = compare x.Key y.Key
      interface IComparable with
          member x.CompareTo(y) =
              match y with
              | null -> 1
              | :? RangePoint<'key,'a> as y -> compare x.Key y.Key
              | _ -> invalidArg "y" "Argument must be a RangePoint"
      override x.GetHashCode() = hash x.Key
      override x.Equals(y) =
          match y with
          | :? RangePoint<'key,'a> as y -> x.Key = y.Key
          | _ -> false
  
  [<Struct>]
  /// 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: comparison and 'key: equality> = private RangeMap of RangePoint<'key,'a> []
  
  module RangeMap =
  
      /// An empty `RangeMap`.
      [<CompiledName("Empty")>]
  
negative.code:     let internal consistencyCheck arr =
          let rec impl k0 =
              function
              | RMCons((k1, k2, _), xs) when smaller k0 k1 && smallerOrEqual k1 k2 -> impl k2 xs
              | RMNil -> Some <| RangeMap arr
              | _ -> None
          Array.sortInPlace arr
          match ReadOnlyMemory arr with
          | RMCons((k1, k2, _), xs) when smallerOrEqual k1 k2 -> impl k2 xs
          | RMCons(_, _) -> None
          | RMNil -> Some <| RangeMap arr
  
      /// Creates a `RangeMap` from an array of a range of keys and their corresponding value.
  