anchor.diff:  
       let exactlyOne (q : IQueryable<'a>) =
           q.Single()
  +    let exactlyOneTask (q : IQueryable<'a>) =
  +        q.SingleAsync()
       let exactlyOneAsync (q : IQueryable<'a>) =
  -        q.SingleAsync()
  +        q
  +        |> exactlyOneTask
           |> Async.AwaitTask
   
       let filter (f : Quotations.Expr<'a -> bool>) (q : IQueryable<'a>) =
  
positive.code: 
      let toList (q : IQueryable<'a>) =
          q.ToList()
  
      let toListAsync (q : IQueryable<'a>) =
          q.ToListAsync()
          |> Async.AwaitTask
  
      let tryExactlyOne (q : IQueryable<'a>) =
          q.SingleOrDefault()
          |> Option.ofNullableRecord
  
      let tryExactlyOneAsync (q : IQueryable<'a>) =
          q.SingleOrDefaultAsync()
          |> Async.AwaitTask
          |> Async.map Option.ofNullableRecord
  
      let tryHead (q : IQueryable<'a>) =
          q.FirstOrDefault()
          |> Option.ofNullableRecord
  
      let tryHeadAsync (q : IQueryable<'a>) =
          q.FirstOrDefaultAsync()
          |> Async.AwaitTask
          |> Async.map Option.ofNullableRecord
  
      let count<'a> (f : Quotations.Expr<'a -> bool>) (q : IQueryable<'a>) =
          f
  
negative.code:         | Int i -> loadByInt<'a> i
          | Int64 i -> loadByInt64<'a> i
  
  
      let loadByGuidTask<'a> (id : Guid) (session : IDocumentSession) =
          session.LoadAsync<'a>(id)
          |> Task.map Option.ofNullableRecord
  
      let loadByIntTask<'a> (id : int32) (session : IDocumentSession) =
          session.LoadAsync<'a>(id)
          |> Task.map Option.ofNullableRecord
  
      let loadByInt64Task<'a> (id : int64) (session : IDocumentSession) =
          session.LoadAsync<'a>(id)
          |> Task.map Option.ofNullableRecord
  
      let loadByStringTask<'a> (id : string ) (session : IDocumentSession) =
          session.LoadAsync<'a>(id)
          |> Task.map Option.ofNullableRecord
  
      let loadByGuidAsync<'a> (id : Guid) (session : IDocumentSession) =
          session
          |> loadByGuidTask<'a>(id)
          |> Async.AwaitTask
  
      let loadByIntAsync<'a> (id : int32) (session : IDocumentSession) =
          session
          |> loadByIntTask<'a>(id)
          |> Async.AwaitTask
  
      let loadByInt64Async<'a> (id : int64) (session : IDocumentSession) =
          session
          |> loadByInt64Task<'a>(id)
          |> Async.AwaitTask
  
      let loadByStringAsync<'a> (id : string ) (session : IDocumentSession) =
          session
          |> loadByStringTask<'a>(id)
          |> Async.AwaitTask
  
      let loadTask<'a> (pk : PrimaryKey) (session : IDocumentSession) =
          session
          |>  match pk with
              | Guid g -> loadByGuidTask<'a> g
              | String s -> loadByStringTask<'a> s
              | Int i -> loadByIntTask<'a> i
              | Int64 i -> loadByInt64Task<'a> i
      let loadAsync<'a> (pk : PrimaryKey) (session : IDocumentSession) =
          session
          |> loadTask<'a> pk
          |> Async.AwaitTask
  
      let query<'a> (session : IDocumentSession) =
          session.Query<'a>()
  
      let sql<'a> (session : IDocumentSession) string parameters =
          session.Query<'a>(string, parameters)
      let sqlTask<'a> (session : IDocumentSession) string parameters =
          session.QueryAsync<'a>(string, parameters=parameters)
      let sqlAsync<'a> (session : IDocumentSession) string parameters =
          sqlTask<'a> session string parameters
          |> Async.AwaitTask
  
  
      let saveChanges (session : IDocumentSession) =
          session.SaveChanges()
      let saveChangesTask (session : IDocumentSession) =
          session.SaveChangesAsync()
      let saveChangesAsync (session : IDocumentSession) =
          session
          |> saveChangesTask
          |> Async.AwaitTask
  
      let storeSingle (session : IDocumentSession) entity  =
          session.Store([|entity|])
      let storeMany (session : IDocumentSession) (entities : #seq<_>)  =
          entities
          |> Seq.toArray
          |> session.Store
  
      // PATCH.
      let patch<'a> (id : Guid) (session : IDocumentSession) =
  