F# - Writing a function that accepts both non-generic and generic argument - f#

Question

I defined await function like this:
let await (task : Task<'a>) =
task |> Async.AwaitTask |> Async.RunSynchronously
and two tasks like this:
let stringTask = new Task<string>(fun () -> "something")
let unitTask = new Task(fun () -> printf "something")
Calling them like this:
let stringResult = await stringTask
await unitTask
But the second is not generic and I can't call await for it, thus I edited the function argument like this:
let await (task : Task) =
task |> Async.AwaitTask |> Async.RunSynchronously
The problem is now the await stringTask is returning unit instead of string.
How should I write the await function to accept both Task<'a> and Task as the parameter and await it?

Answer 1

Your original definition for await is fine.
The problem is with unitTask which is not generic. Make it generic the same way you did with stringTask:
let unitTask = new Task<unit>(fun () -> printf "something")
If you want to handle both generic Task<'a> and non-generic Task, you have 2 options.
Create 2 await functions (the functional way):
let await (task : Task<'a>) = task |> Async.AwaitTask |> Async.RunSynchronously
let awaitUnit (task : Task ) = task |> Async.AwaitTask |> Async.RunSynchronously
or create 2 Await members for instance on type Task (the OO way):
type Task with
static member Await (task : Task ) = task |> Async.AwaitTask |> Async.RunSynchronously
static member Await (task : Task<'a>) = task |> Async.AwaitTask |> Async.RunSynchronously
By convention members use Pascal case so I used Await instead of await.
Remember to call task.Start() before you call your await.

Answer 2

Async.AwaitTask already has overloads for both Task<'a> and Task, so unless you really need a helper function, you can use it directly:
let stringResult = Async.AwaitTask stringTask |> Async.RunSynchronously
Async.AwaitTask unitTask |> Async.RunSynchronously
And if this is your actual code and you really need to block the thread to wait for those results, you can also just use the Task API directly to save the Task -> Async translation overhead:
let stringResult = stringTask.Result
unitTask.Wait()

Answer 3

You could create a Task -> Task<unit> helper function to convert Task objects you get from the API into Task<unit>. I suspect that this isn't the best way to do it, since it has been a while since I've paid much attention to the differences between F# async and the framework's Task-based asynchrony, but this works in a trivial extension of your example:
open System.Threading
open System.Threading.Tasks
let toUnitTask (t : Task) =
new Task<_>(fun () -> t.Start(); t |> Async.AwaitTask |> Async.RunSynchronously)
let await (task : Task<_>) =
task |> Async.AwaitTask |> Async.RunSynchronously
let stringTask = new Task<string>(fun () -> Thread.Sleep 3000; "something")
let unitTask = new Task(fun () -> Thread.Sleep 2000; printfn "something") |> toUnitTask
stringTask.Start()
unitTask.Start()
let stringResult = await stringTask
await unitTask