Discussion: await pattern

[alrz]

If the target expression is awaitable, we may use await to await that object.

This is specifically useful with tuple patterns to do a pattern-match in parallel.

switch ((FuncAsync1(), FuncAsync2()))
{
  case (await true, _): 
  case (_, await true):
    // we reach here when any of tasks is completed with the value of `true`,
    // otherwise we immediately run the default case, if any.
    return true;
  default:
    return false;
}

Implementing something like this with WhenAny is not as effective (besides that every task must be of a same type) you wouldn't know that which task is completed and you have to compare the returned task with each one of them. Also this would work with any awaitable including IOservable<T> via Rx.

Related: dotnet/roslyn#5187, http://tomasp.net/blog/fsharp-variations-joinads.aspx

[svick]

How would this deal with exceptions?

What happens if the first task to complete fails with an exception? Would that rethrow the exception?

What happens when the second task to complete fails? Would that ignore the exception? Currently, I believe the language never ignores exceptions (the library might, but that's not the same thing).

this would work with any awaitable including IObservable<T> via Rx.

I'm not sure IObservable<T> is a good example, since it can be easily converted to task by calling .ToTask().

[alrz]

@svick

If the first task fails with an exception, the containing task also fails. If the second task fails, we ignore it just like _ = FAsync() would.

[jnm2]

I know what it means but the syntax await true bothers me.

[alrz]

you're waiting for a true, makes sense for me :)

[jnm2]

@alrz You're waiting for any bool value, yes. Typically you only wait for an awaitable. Just don't put a GetAwaiter extension method on bool 😆

[alrz]

The awaitable on bool would be awaited if you use await await x as you would need to do today. Further, if you want to ignore the awaited value and just confirm its success you'll need to use await _. Same would apply to Task or any other non-generic task-like.

[jnm2]

you're waiting for a true, makes sense for me :)

Actually if that's what await true means, it's misleading. It makes it sound like if it gets a false, it'll keep waiting.

[alrz]

I'm not native so I'm not sure how it exactly reads but I think that's the most sensible syntax to use here.

Actually if that's what await true means, it's misleading. It makes it sound like if it gets a false, it'll keep waiting.

I meant that we actually wait until the awaitable returns, from there. it's just a constant pattern.

[aluanhaddad]

@alrz I also think it reads oddly. For comparison, imagine a strange (and incorrectly implemented) WaitFor method

TResult WaitFor<TResult>(Func<bool> condition, Func<TResult> whenTrue)
{
    var @true = condition();
    while (@true is false)
    {
        Thread.Sleep(100); // obviously broken
        @true = condition();
    }
    return whenTrue();
}

var message = WaitFor(() => true, () => "always");