anchor.diff:          member __.WriteETag(path : string, writer : Stream -> Async<'R>) : Async<ETag * 'R> = async {
               let path = normalize path
               initDir <| Path.GetDirectoryName path
  -            use fs = retry ioConcurrencyPolicy (fun () -> new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
  +            use fs = retry fileAccessRetryPolicy (fun () -> new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
               let! r = writer fs
               // flush to disk before closing stream to ensure etag is correct
               if fs.CanWrite then fs.Flush(flushToDisk = true)
  
positive.code: 
      // IOException will be signifies attempt to perform concurrent writes of file.
      // An exception to this rule is FileNotFoundException, which is a subtype of IOException.
      static let ioConcurrencyPolicy = 
          Policy(fun retries exn ->
              match exn with
              | :? FileNotFoundException 
              | :? DirectoryNotFoundException -> None
              | :? UnauthorizedAccessException when retries < 5 -> TimeSpan.FromMilliseconds 200. |> Some
              | :? IOException -> TimeSpan.FromMilliseconds 200. |> Some
              | _ -> None)
  
      let initDir dir =
  
negative.code:         }
  
          member __.DeleteFile(file : string) = async {
              try return! retryAsync fileDeleteRetryPolicy (async { return File.Delete(normalize file) })
              with :? DirectoryNotFoundException -> return ()
          }
  
  