Knowing where async continuations occur?

[mike-kaufman]

One of the biggest problems now is knowing where async transitions happen. Is there a way to better communicate this through language constructs? e.g., instead of

var promise =…
promise.then(function f() {
});

We could have

var promise =…
promise.then(continuation f() {
});

This has several benefits as I think about it:

• The notion that a function takes a “continuation” as an argument (instead of a function), makes it explicit in code where the transition occurs.
• The “link event” can be updated to happen precisely when a “continuation” is created, thus the link happens closer to user code, vs buried deep inside some library.
• We can better enforce async-transition semantics/correctness by having a clear distinction between a function and a continuation. E.g., we could assert that a continuation is invoked in a seperate context than where it was created.
• this is a formalization of the pattern to wrap up a callback so it will propagate a callback, e.g., https://github.com/othiym23/node-continuation-local-storage#namespacebindcallback-context.

Now, this has implications on the language, which means it’s a bigger deal, but it’s such a fundamental concept that I wonder if it makes sense to pursue this. Nice thing is above is easily transpile-able & thus has a nice back-compat story.