anchor.diff:                              else async { return doc }
                           doc.Foo <- "Bar"
                           do! session.SaveChangesAsync() |> Util.taskToAsync
  -                    }
  +                    }) |> runUntilSuccess
               }
           }
           |> Async.Parallel
  
positive.code: 
          let myEvents = (streams, streamValues) |> Seq.unfold generateStream
  
          seq {
              yield async {
                  for (key,value) in myEvents do
  
negative.code: 
      let cache = new MemoryCache("RavenBatchWrite")
  
      let writeBatch _ docs = async {
          let originalDocMap = 
              docs
              |> Seq.map (fun (key, doc, _, callback) -> (key, (doc, callback)))
              |> Map.ofSeq
  
          let! result = BatchOperations.writeBatch documentStore docs
          match result with
          | Some (batchResult, docs) ->
              for docResult in batchResult do
                  let (doc, callback) = originalDocMap.[docResult.Key]
                  cache.Set(docResult.Key, (doc, docResult.Etag) :> obj, DateTimeOffset.MaxValue) |> ignore
                  do! callback true
          | None ->
              for (docKey, _, _, callback) in docs do
                  cache.Remove(docKey) |> ignore
                  do! callback false
      }
  
      let writeQueue = new WorktrackingQueue<unit, BatchWrite>((fun _ -> Set.singleton ()), writeBatch, 10000, 10) 
  