I predict they will come to the conclusion that they backed the wrong horse with Flow over TypeScript; v7 will be written in Scala or Scala.js .

There is the odd sense of randomness to the choices in all these CLI upgrades. Can't quite put my finger on it. It brings to mind the saga of Wasabi.

I think the idea with Flow is you just have JSDoc type annotations, so you get strong typing without transpiration.

There is a comment convention where you can add Flow type annotations and definitions to vanilla JS:

    x /*: T*/
    
    /*::
    type T = {
      ...
    }
    */

But in practice I don't think it's pushed as being preferable to the invasive syntax.

I believe TypeScript has the JSDoc feature as well, although it's much more recent.

Instead of using Promise.all, wouldn't an approach like this work?

    const a = taskA();
    const b = taskB();
    const c = taskC();

    const result = [await a, await b, await c];

These are not the same. Promise.all guarantees a is executed then b then c.

Your version guarantees the three are executed before moving forward. The order may differ on each run.

FYI, Promise.all does not guarantee that. It doesn't orchestrate actually running the Promises at all (this is impossible the way Promises work), just that they're all resolved at the end, with results in the same order they were passed in.

What is the difference then?

None from the perspective of the consumer.

The implementation of Promise.all could use one array for results and fill it in any order as soon as any promise resolves while awaits will always proceed in strict order (like a generator). But that's an implementation detail that a JS programmer doesn't need to think about.

Thanks for the clarification.

I believe `await` is sequential in the scope. `Promise.all` would be truly parallel.

edit: just checked and your version is indeed parallel. Interesting.

Yup - all promises are "started" before you await them.

I still typically prefer Promise.all though. It's a bit more obvious what's going on (IMO) and you can skip the additional lines for assigning the promises to variables.

Very cool, I never thought about doing it this way!

Instead of awaiting IO in CLI tools I just use the sync version