anchor.diff:                  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 {
  
positive.code:     }
  
  let private makeRelease draft owner project version prerelease (notes:seq<string>) (client : Async<GitHubClient>) =
      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! 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 }
      }
  
  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>) =
      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! asset = Async.AwaitTask <| draft'.Client.Release.UploadAsset(draft'.DraftRelease, assetUpload)
          printfn "Uploaded %s" asset.Name
          return draft'
      }
  
  let releaseDraft (draft : Async<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
      }
  
negative.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
  