Add the ability to overloadable generics that prefer more explicit types.

[cportwood]

Is there any way to allow the compiler to prefer more explicit overloads when a generic is overloaded. This is a very common issue when dealing with Async Extension Methods. In this simple scenario Adding an Async suffix would be the simple solution but that can quickly become problematic in more complex scenarios when building a more functional/Fluent library. I use async as that is where I run into it the most, but I have run into numerous places where this would apply.

    public static T ExtensionMethod<T>(this Func<T> func){
        return func();
    }
    
    public async static Task<T> ExtensionMethod<T>(this Func<Task<T>> func){
        return await func();
    }

[CyrusNajmabadi]

@cportwood could you clarify what the issue is? The compiler will prefer the more explicit form here:

As you can see, it's calling the second method, instantiated with int, versus teh first, instantiated with Task<int>.

[cportwood]

@CyrusNajmabadi Thanks, I will do some investigation. My assumption is obviously incorrect for the simple example. I will do some work after I have some time and come back with a better example. I am working with a library where chained Func<T,R> and Func<T, Task> are causing issues and I ran into a similar issue with another project. I will reopen when I come up with a valid example. Thanks for the rapid response.

[CyrusNajmabadi]

You're welcome :)

[TahirAhmadov]

In my experience, the problem I've faced is the other way around: when I mistakenly specify async () => { ... } lambda as an argument, it resolves to a method which expects Action, even though the lambda returns Task and not void.

[Joe4evr]

That's just inference based on available overloads. An async lambda does not naturally return Task, but inference prefers giving it a Task-returning signature if an overload accepting such a delegate type is available. It's only if that isn't available it tries again with a void returning signature.

[cportwood]

@TahirAhmadov Yes, I generally have to overload with Task, Task<T>, ValueTask, ValueTask<T> if I wish to allow vode like returns.