anchor.diff:            finally
               exitLockIf syncRoot entered
   
  -        member p.CurrentKey with get() = currentKey.Value //if index.Value >= 0 then this.GetKeyByIndex(index.Value) else Unchecked.defaultof<'K> //currentKey.Value
  -
  -        member p.CurrentValue with get() = currentValue.Value //if index.Value >= 0 then this.values.[index.Value] else Unchecked.defaultof<'V> //currentValue.Value
  +        member p.CurrentKey with get() = currentKey
  +
  +        member p.CurrentValue with get() = currentValue
   
         interface IEnumerator<KVP<'K,'V>> with
  -        member p.Current with get() : KVP<'K,'V> = KeyValuePair(currentKey.Value, currentValue.Value)
  +        member p.Current with get() : KVP<'K,'V> = KeyValuePair(currentKey, currentValue)
           member p.Current with get() : obj = box p.Current
           member p.MoveNext() = 
             let entered = enterLockIf syncRoot isSynchronized
             try
  -            if cursorVersion.Value =  this.orderVersion then
  -              if index.Value < (this.size - 1) then
  -                index := !index + 1
  +            if cursorVersion =  this.orderVersion then
  +              if index < (this.size - 1) then
  +                index <- index + 1
                   // TODO!! (perf) regular keys were supposed to speed up things, not to slow down by 50%! 
  -                currentKey := this.GetKeyByIndexUnchecked(!index)
  -                currentValue := this.values.[!index]
  +                currentKey <- this.GetKeyByIndexUnchecked(index)
  +                currentValue <- this.values.[index]
                   true
                 else
                   //p.Reset() // NB! Do not reset cursor on false MoveNext
                   false
               else  // source change
  -              cursorVersion :=  this.orderVersion // update state to new this.version
  +              cursorVersion <- this.orderVersion // update state to new this.version
                 let mutable kvp = Unchecked.defaultof<_>
  -              let position = this.TryFindWithIndex(currentKey.Value, Lookup.GT, &kvp) // reposition cursor after source change //currentKey.Value
  +              let position = this.TryFindWithIndex(currentKey, Lookup.GT, &kvp) // reposition cursor after source change //currentKey.Value
                 if position > 0 then
  -                index := position
  -                currentKey := kvp.Key
  -                currentValue := kvp.Value
  +                index <- position
  +                currentKey <- kvp.Key
  +                currentValue <- kvp.Value
                   true
                 else  // not found
                   //p.Reset() // NB! Do not reset cursor on false MoveNext
  
positive.code:           finally
              exitLockIf syncRoot entered
          member p.Reset() = 
            cursorVersion :=  this.orderVersion // update state to new this.version
            index := -1
            currentKey := Unchecked.defaultof<'K>
            currentValue := Unchecked.defaultof<'V>
  
          member p.Dispose() = 
            p.Reset()
  
negative.code:   // TODO(?) replace with a mutable struct, like in SCG.SortedList<T>, there are too many virtual calls and reference cells in the most critical paths like MoveNext
    // NB Object expression with ref cells are surprisingly fast compared to a custom class or even a struct
    member internal this.GetCursor(index:int,cursorVersion:int,currentKey:'K, currentValue:'V) =
      let mutable index = index
      let mutable cursorVersion = cursorVersion
      let mutable currentKey : 'K = currentKey
      let mutable currentValue : 'V = currentValue
      let mutable isBatch = false
  
      let observerStarted = ref false
      let mutable semaphore : SemaphoreSlim = Unchecked.defaultof<_>
  