Support F# Async<'T> as an awaitable type in minimal APIs

[brianrourkeboll]

Is there an existing issue for this?

• I have searched the existing issues

Is your feature request related to a problem? Please describe the problem.

The F# Async<'T> type is supported as an awaitable return type for ASP.NET Core controller methods, but not for endpoints added via the .Map* minimal APIs extension methods.

Describe the solution you'd like

I'd like to be able to return F# async values and have them awaited when using minimal APIs endpoints just as I can for controller action methods.

Examples

• Basic controller example:

  type MyController () =
      inherit ControllerBase ()
      // The framework automatically awaits the async value.
      [<HttpGet>]
      member _.Get () = async { return [1 .. 10] }

• Minimal APIs example:

  // This does not await.
  app.MapGet ("/", Func<Async<int list>> (fun () -> async { return [1 .. 10] }))

  // Converting the F# async value to a task is required.
  app.MapGet ("/", Func<Task<int list>> (fun () -> async { return [1 .. 10] } |> Async.StartAsTask))

Additional context

I can perform the conversion myself using code like this:

open System
open System.Linq.Expressions
open System.Threading
open System.Threading.Tasks

let taskify (f : Delegate) =
    if isNull f then
        nullArg (nameof f)

    let meth = f.Method
    let returnTy = meth.ReturnType
    if returnTy.IsGenericType && returnTy.GetGenericTypeDefinition () = typedefof<Async<_>> then
        let resultTy = returnTy.GetGenericArguments () |> Array.exactlyOne
        let parameters = [| for param in meth.GetParameters () -> Expression.Parameter (param.ParameterType, param.Name) |]
        let lambda =
            Expression.Lambda
                (
                    Expression.Call
                        (
                            (typeof<Async>.GetMethod (nameof Async.StartAsTask)).MakeGenericMethod resultTy,
                            Expression.Invoke
                                (
                                    Expression.Constant f,
                                    box parameters :?> Expression array
                                ),
                            Expression.MakeMemberAccess (null, typeof<TaskCreationOptions option>.GetProperty (nameof None)),
                            Expression.MakeMemberAccess (null, typeof<CancellationToken option>.GetProperty (nameof None))
                        ),
                    parameters
                )

        lambda.Compile ()
    else
        f

let d = Func<_, _> (fun (i : int) -> async { return i })
((taskify d :?> Func<int, Task<int>>).Invoke 3).Result

But if I do so, I lose metadata from the original delegate, including parameter names, which affects the generated Swagger/Open API definition, among other things.

[mitchdenny]

Unfortunately Async is a language specific type in F#. I don't think we could take a dependency on that.

[brianrourkeboll]

Unfortunately Async is a language specific type in F#. I don't think we could take a dependency on that.

Yes, although it is already supported in the framework dynamically for controller action methods.

[En3Tho]

Why not just use task { ... } directly?
Why not just create a set of overloads for async and call StartAsTask inside?

My experience with minimal apis and F# is that you need a dedicated set of Func overloads anyway or else you have to littler your code with explicit Func annotations everywhere

[captainsafia]

Triage: We think we might've missed adding support for this scenario and would welcome any PRs!

[ghost]

We've moved this issue to the Backlog milestone. This means that it is not going to be worked on for the coming release. We will reassess the backlog following the current release and consider this item at that time. To learn more about our issue management process and to have better expectation regarding different types of issues you can read our Triage Process.

[lucasteles]

is there any update on this?