anchor.diff:          fBatch.Present.Invoke(batch)
         else
           let factory = Func<_>(batch.GetCursor)
  -        let c() = new MapValuesCursor<'K,'V,'V2>(factory, f, OptionalValue.Missing) :> ICursor<'K,'V2>
  +        let c() = new BatchMapValuesCursor<'K,'V,'V2>(factory, f, fBatch) :> ICursor<'K,'V2>
           CursorSeries(Func<_>(c)) :> IReadOnlyOrderedMap<'K,'V2>
   
       member this.CurrentBatch
  
positive.code: 
      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>
          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>
  
      interface IEnumerator<KVP<'K,'V2>> with    
        member this.Reset() = cursor.Reset()
  
negative.code: //
  // Our benchmark confirms that the slowdown of .Repeat(), .ReadOnly(), .Map(...) and .Filter(...) is quite small 
  
  
  and
    /// Map keys and values to new values
    internal BatchCursor<'K,'V,'V2>(cursorFactory:Func<ICursor<'K,'V>>) =
      let foo = "bar"
  
  and
    // NB Remember that a cursor is single-threaded
  
    /// Map values to new values
    internal BatchMapValuesCursor<'K,'V,'V2>(cursorFactory:Func<ICursor<'K,'V>>, f:Func<'V,'V2>, fBatch:Func<IReadOnlyOrderedMap<'K,'V>,IReadOnlyOrderedMap<'K,'V2>> opt)=
      let cursor : ICursor<'K,'V> =  cursorFactory.Invoke()
      let f : Func<'V,'V2> = f
      let fBatch = fBatch
      // for forward-only enumeration this could be faster with native math
      // any non-forward move makes this false and we fall back to single items
      let mutable preferBatches = fBatch.IsPresent
      let mutable batchStarted = false
      let mutable batch = Unchecked.defaultof<IReadOnlyOrderedMap<'K,'V2>>
      let mutable batchCursor = Unchecked.defaultof<ICursor<'K,'V2>>
      let mutable nextBatch = Unchecked.defaultof<IReadOnlyOrderedMap<'K,'V2>>
      let mutable nextBatchTask = Unchecked.defaultof<Task<bool>>
  
      member this.CurrentKey: 'K = 
        if batchStarted then batchCursor.CurrentKey
        else cursor.CurrentKey
      member this.CurrentValue: 'V2 = 
        if batchStarted then batchCursor.CurrentValue
        else f.Invoke(cursor.CurrentValue)
      member this.Current: KVP<'K,'V2> = KVP(this.CurrentKey, this.CurrentValue)
  
      member private this.MapBatch(batch:IReadOnlyOrderedMap<'K,'V>) =
  