await out as a shorthand for TaskCompletionSource

[Thaina]

There was so many legacy API that utilize callback for async. Even if we could use TaskCompletionSource it almost always verbose. I think we should have some syntax to shorthand the code that would always the same

var source = new TaskCompletionSource<AnyType>();
LegacyCallback((any) => source.TrySetResult(any));
var result = await source.Task;
DoSomethingWithResult(result);

Maybe await out like this

LegacyCallback(await out var result); // just the same construction as TaskCompletionSource above
DoSomethingWithResult(result);

If the callback is Action<T0,T1> then it would convert to tuple

LegacyCallback(await out var (result,reason)); // Action<bool,string>
DoSomethingWithResult(result);

[HaloFour]

public static class TaskHelpers {
    public static Action<T> AwaitCallback<T>(out Task<T> task) {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        task = tcs.Task;
        return value => tcs.TrySetResult(value);
    }
}

LegacyCallback(AwaitCallback(out var task));
var result = await task;

[Thaina]

@HaloFour Could your AwaitCallback<T> function know it return type without manually putting generic argument?

[HaloFour]

@Thaina

I don't believe generic inference can handle that today, no.

[Thaina]

@HaloFour Right, that's why I request this as language feature so it would just guess the type and transpile by compiler

[HaloFour]

There are other proposals that seek to improve generic type inference in these kinds scenarios. I'd suggest that would probably be a better approach.

This language feature seems like it would only benefit a very few narrow cases and only if the compiler always assumes that a function that accepts a delegate represents some kind of async callback, which is very rarely the case.