anchor.diff:          this.size <- dictionary.Value.Count
           // TODO review
           if couldHaveRegularKeys then // if could be regular based on initial check of comparer type
  -          let isReg, step, firstArr = rkCheckArray this.keys this.size (comparer :?> IKeyComparer<'K>)
  +          let isReg, step, firstArr = this.rkCheckArray this.keys this.size (comparer :?> IKeyComparer<'K>)
             couldHaveRegularKeys <- isReg
             if couldHaveRegularKeys then 
               this.keys <- firstArr
               rkLast <- rkKeyAtIndex (this.size - 1)
     //#endregion
   
  +  member private this.rkCheckArray (sortedArray:'K[]) (size:int) (dc:IKeyComparer<'K>) : bool * int * 'K array = 
  +    if size > sortedArray.Length then raise (ArgumentException("size is greater than sortedArray length"))
  +    if size < 1 then
  +      true, 0, [|Unchecked.defaultof<'K>;Unchecked.defaultof<'K>|]
  +    elif size < 2 then
  +      true, 0, [|sortedArray.[0];Unchecked.defaultof<'K>|]
  +    elif size < 3 then 
  +      true, dc.Diff(sortedArray.[1], sortedArray.[0]), [|sortedArray.[0];sortedArray.[1]|]
  +    else
  +      let firstDiff = dc.Diff(sortedArray.[1], sortedArray.[0])
  +      let mutable isReg = true
  +      let mutable n = 2
  +      while isReg && n < size do
  +        let newDiff = dc.Diff(sortedArray.[n], sortedArray.[n-1])
  +        if newDiff <> firstDiff then
  +          isReg <- false
  +        n <- n + 1
  +      if isReg then
  +        true, firstDiff, [|sortedArray.[0];sortedArray.[1]|]
  +      else
  +        false, 0, Unchecked.defaultof<'K[]>
   
   #if FX_NO_BINARY_SERIALIZATION
   #else
  
positive.code:     let step = rkGetStep()
      Array.init this.values.Length (fun i -> if i < this.size then diffCalc.Add(this.keys.[0], i*step) else Unchecked.defaultof<'K>)
  
    let rkCheckArray (sortedArray:'K[]) (size:int) (dc:IKeyComparer<'K>) : bool * int * 'K array = 
      if size > sortedArray.Length then raise (ArgumentException("size is greater than sortedArray length"))
      if size < 1 then
        true, 0, [|Unchecked.defaultof<'K>;Unchecked.defaultof<'K>|]
      elif size < 2 then
        true, 0, [|sortedArray.[0];Unchecked.defaultof<'K>|]
      elif size < 3 then 
        true, dc.Diff(sortedArray.[1], sortedArray.[0]), [|sortedArray.[0];sortedArray.[1]|]
      else
        let firstDiff = dc.Diff(sortedArray.[1], sortedArray.[0])
        let mutable isReg = true
        let mutable n = 2
        while isReg && n < size do
          let newDiff = dc.Diff(sortedArray.[n], sortedArray.[n-1])
          if newDiff <> firstDiff then
            isReg <- false
          n <- n + 1
        if isReg then
          true, firstDiff, [|sortedArray.[0];sortedArray.[1]|]
        else
          false, 0, Unchecked.defaultof<'K[]>
  
    do
      let tempCap = if capacity.IsSome then capacity.Value else 1
      this.keys <- Array.zeroCreate (if couldHaveRegularKeys then 2 else tempCap) // regular keys are the first and the second value, their diff is the step
  
negative.code: //      newMap.RemoveMany(key, direction) |> ignore
  //      newMap :> IImmutableOrderedMap<'K,'V>
  
    //#endregion
  
    //#region Constructors
  
  