[vlmutolo]

It’s important to be able to see where the async function might pause execution.

For example, if you’re holding a mutex lock, you probably want to avoid holding it “across” an await point so that it’s not locked for longer than necessary if the function is paused.

[Arnavion]

I agree that the explicit yield syntax is good.

To play devil's advocate though, the case of Mutex specifically has it going for it that MutexGuard is !Send, so it's a compiler error if a MutexGuard is held across an await point in a Send Future. But yes if your Future is also !Send then the compiler will allow it. In that case, your only recourse is that clippy has lints for holding Mutex and RefCell guards across await points, as long as you're running it and paying attention to it of course.

[k_bx]

I disagree. It should be a compiler warning, maybe a "clippy" one, in such cases.

Btw the problem of sync code blocking async code is very real and also needs to be resolved, adding explicit `.blocking` to every blocking call is just as bad as explicit .await at every line.

Also, I like Haskell approach of being able to introduce syntax extensions at a file-level, so that for code that'd benefit from explicit await – I'd rather let author have it explicit.

[PenguinCoder]

> It’s important to be able to see where the async function might pause execution.

Why? Your example does not prove the point.