anchor.diff:      }
   
   let private makeRelease draft owner project version prerelease (notes:seq<string>) (client : Async<GitHubClient>) =
  -    async {
  +    retryWithArg 5 client <| fun client' -> async {
           let data = new NewRelease(version)
           data.Name <- version
           data.Body <- String.Join(Environment.NewLine, notes)
           data.Draft <- draft
           data.Prerelease <- prerelease
  -        let! client' = client
           let! draft = Async.AwaitTask <| client'.Release.Create(owner, project, data)
           let draftWord = if data.Draft then " draft" else ""
           printfn "Created%s release id %d" draftWord draft.Id
  -        return { Client = client'
  -                 Owner = owner
  -                 Project = project
  -                 DraftRelease = draft }
  -    } |> retry 5
  +        return {
  +            Client = client'
  +            Owner = owner
  +            Project = project
  +            DraftRelease = draft }
  +    }
   
   let createDraft owner project version prerelease notes client = makeRelease true owner project version prerelease notes client
   let createRelease owner project version prerelease notes client = makeRelease false owner project version prerelease notes client
   
   let uploadFile fileName (draft : Async<Draft>) =
  -    async {
  +    retryWithArg 5 draft <| fun draft' -> async {
           let fi = FileInfo(fileName)
           let archiveContents = File.OpenRead(fi.FullName)
           let assetUpload = new ReleaseAssetUpload(fi.Name,"application/octet-stream",archiveContents,Nullable<TimeSpan>())
  -        let! draft' = draft
           let! asset = Async.AwaitTask <| draft'.Client.Release.UploadAsset(draft'.DraftRelease, assetUpload)
           printfn "Uploaded %s" asset.Name
           return draft'
  -    } |> retry 5
  +    }
   
   let releaseDraft (draft : Async<Draft>) =
  -    async {
  -        let! draft' = draft
  +    retryWithArg 5 draft <| fun draft' -> async {
           let update = draft'.DraftRelease.ToUpdate()
           update.Draft <- Nullable<bool>(false)
           let! released = Async.AwaitTask <| draft'.Client.Release.Edit(draft'.Owner, draft'.Project, draft'.DraftRelease.Id, update)
           printfn "Released %d on github" released.Id
  -    } |> retry 5
  +    }
  
positive.code: 
  let private isRunningOnMono = System.Type.GetType ("Mono.Runtime") <> null
  
  let rec private retry count asyncF =
      // This retry logic causes an exception on Mono:
      // https://github.com/fsharp/fsharp/issues/440
  
negative.code:                 return! asyncF
              with _ when count > 0 -> return! retry (count - 1) asyncF
          }
  
  /// Retry the Octokit action count times after input succeed
  let private retryWithArg count input asycnF =
      async {
          let! choice = input |> Async.Catch
          match choice with
          | Choice1Of2 input' ->
              return! (asycnF input') |> retry count
          | Choice2Of2 ex ->
              return captureAndReraise ex
      }
  
  let createClient user password =
      async {
  