anchor.diff:          | 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.LoadAsync<'a>(id)
  -        |> Async.AwaitTask
  -        |> Async.map Option.ofNullableRecord
  +        session
  +        |> loadByGuidTask<'a>(id)
  +        |> Async.AwaitTask
   
       let loadByIntAsync<'a> (id : int32) (session : IDocumentSession) =
  -        session.LoadAsync<'a>(id)
  -        |> Async.AwaitTask
  -        |> Async.map Option.ofNullableRecord
  +        session
  +        |> loadByIntTask<'a>(id)
  +        |> Async.AwaitTask
  +
       let loadByInt64Async<'a> (id : int64) (session : IDocumentSession) =
  -        session.LoadAsync<'a>(id)
  -        |> Async.AwaitTask
  -        |> Async.map Option.ofNullableRecord
  +        session
  +        |> loadByInt64Task<'a>(id)
  +        |> Async.AwaitTask
   
       let loadByStringAsync<'a> (id : string ) (session : IDocumentSession) =
  -        session.LoadAsync<'a>(id)
  -        |> Async.AwaitTask
  -        |> Async.map Option.ofNullableRecord
  +        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) =
  -        match pk with
  -        | Guid g -> loadByGuidAsync<'a> g
  -        | String s -> loadByStringAsync<'a> s
  -        | Int i -> loadByIntAsync<'a> i
  -        | Int64 i -> loadByInt64Async<'a> i
  +        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 =
  -        session.QueryAsync<'a>(string, parameters=parameters) |> Async.AwaitTask
  +        sqlTask<'a> session string parameters
  +        |> Async.AwaitTask
  +
   
       let saveChanges (session : IDocumentSession) =
           session.SaveChanges()
  -
  +    let saveChangesTask (session : IDocumentSession) =
  +        session.SaveChangesAsync()
       let saveChangesAsync (session : IDocumentSession) =
  -        session.SaveChangesAsync() |> Async.AwaitTask
  -
  +        session
  +        |> saveChangesTask
  +        |> Async.AwaitTask
   
       let storeSingle (session : IDocumentSession) entity  =
           session.Store([|entity|])
       let storeMany (session : IDocumentSession) (entities : #seq<_>)  =
  -        entities |> Seq.toArray |> session.Store
  +        entities
  +        |> Seq.toArray
  +        |> session.Store
   
       // PATCH.
       let patch<'a> (id : Guid) (session : IDocumentSession) =
  
positive.code:         /// Creates an async computation that runs a mapping function on the result of an async computation
          let map f x = x |> bind (f >> singleton)
  
  
  module Option =
      /// Creates an option from a potentially null record type
      let ofNullableRecord record =
          if (record |> box |> isNull) then None else Some record
  
  
  open System
  
negative.code:             let func = Lambda.ofArity1 part
              pExpr.Increment(func, inc)
  
  module Queryable =
  
      open System.Linq
  