Conversion from Task to Async to Task

Hello! I noticed that there is a conversion from Task to Async to Task here: https://github.com/JordanMarr/SqlHydra/blob/7d24b1d1b8266786bb3e03a17f3e6b214e128a59/src/SqlHydra.Query/QueryContext.fs#L127

and here: https://github.com/JordanMarr/SqlHydra/blob/7d24b1d1b8266786bb3e03a17f3e6b214e128a59/src/SqlHydra.Query/QueryContext.fs#L136

Just for my understanding, is this double conversion really necessary? And possibly correlated, why choose to return a Task and not an Async?

Cheers!

[stoft]

Thank you for the insights, very helpful for my understanding. 🙂

[JordanMarr]

For your convenience, this is the one I created for my current project. I considered adding some of this stuff to the library, but wanted to wait and see what is included in F# 6.0 first.

/// Utility functions for working with tasks.
module Task

open FSharp.Control.Tasks.V2
open System.Threading.Tasks

let bind (f : 'a -> Task<'b>) (x : Task<'a>) = 
    task {
        let! x = x
        return! f x
    }

/// Maps the result of Task<'a> to Task<'b>
let map<'a, 'b> (f : 'a -> 'b) (tsk: Task<'a>) =
    task {
        let! taskValue = tsk
        return f taskValue
    }

let mapSeq<'a, 'b> (f : 'a -> 'b) (itemsTask: Task<'a list>) =
    task {
        let! items = itemsTask
        return items |> Seq.map f
    }

let mapArray<'a, 'b> (f : 'a -> 'b) (itemsTask: Task<'a seq>) =
    task {
        let! items = itemsTask
        return items |> Seq.map f |> Seq.toArray
    }

let awaitIgnore (tsk: Task<'T>) =
    task {
        let! result = tsk
        result |> ignore
    }
    :> Task

let fromResult value = 
    System.Threading.Tasks.Task.FromResult value