anchor.diff:  
       member this.Source: ISeries<'K,'V2> = 
           let factory = Func<_>(cursor.Source.GetCursor)
  -        let c() = new MapValuesCursor<'K,'V,'V2>(cursorFactory, f, fBatch) :> ICursor<'K,'V2>
  +        let c() = new BatchMapValuesCursor<'K,'V,'V2>(cursorFactory, f, fBatch) :> ICursor<'K,'V2>
           CursorSeries(Func<_>(c)) :> ISeries<'K,'V2>
       member this.TryGetValue(key: 'K, [<Out>] value: byref<'V2>): bool =  
         let ok, v = cursor.TryGetValue(key)
         if ok then value <- f.Invoke(v)
         ok
         
  -    member this.Clone() = new MapCursor<'K,'V,'V2>(Func<_>(cursor.Clone), f) :> ICursor<'K,'V2>
  +    member this.Clone() = new BatchMapValuesCursor<'K,'V,'V2>(Func<_>(cursor.Clone), f, fBatch) :> ICursor<'K,'V2>
   
       interface IEnumerator<KVP<'K,'V2>> with    
         member this.Reset() = cursor.Reset()
  
positive.code:         fBatch.Present.Invoke(batch)
        else
          let factory = Func<_>(batch.GetCursor)
          let c() = new MapValuesCursor<'K,'V,'V2>(factory, f, OptionalValue.Missing) :> ICursor<'K,'V2>
          CursorSeries(Func<_>(c)) :> IReadOnlyOrderedMap<'K,'V2>
  
      member this.CurrentBatch
  
negative.code:         // to support multiple calls to this.CurrentBatch
          if batch = Unchecked.defaultof<_> then
            batch <- this.MapBatch(cursor.CurrentBatch)
            // at this point, we could move cursor to a new batch
            // we schedule the next move here because MoveNextBatch could be called 
            // several time without evaluation
          batch
  
      member this.MoveNext(): bool = 
        if not preferBatches then cursor.MoveNext()
        else
          if batchStarted && batchCursor.MoveNext() then // the hot path with just 2 comparisons 
            true
          else
            preferBatches <- cursor.MoveNextBatch(CancellationToken.None).Result
            if preferBatches then
              batchCursor <- this.CurrentBatch.GetCursor() // NB setting batch variable here via this.CurrentBatch
              batchStarted <- batchCursor.MoveNext()
              batchStarted
            else cursor.MoveNext()
  
      member this.MoveNextBatch(cancellationToken: Threading.CancellationToken): Task<bool> =
        if nextBatchTask = Unchecked.defaultof<_> then // there is no outstanding move
          cursor.MoveNextBatch(cancellationToken).ContinueWith(
              (fun (antecedant : Task<bool>) ->
                // clean batch holder so that it could be refilled with the new cursor batch
                batch <- Unchecked.defaultof<IReadOnlyOrderedMap<'K,'V2>>
                nextBatchTask <- Task.Run(fun _ ->
                  cursor.MoveNextBatch(cancellationToken)
                  failwith "TODO"
                  true
                )
                antecedant.Result
  