Proposal: `await.all {...}` for parallelism

manuelbarzi manuelbarzi at gmail.com
Tue Nov 26 14:13:52 UTC 2019


> OK I'm even more confused now. x1 is surely not a resolved value until all
> the next "non parallel await" so is it "undefined" until then?
>

as a `const` x1 does not exist until those parallel awaits `await||` (for
p1 and p3) are resolved (same for x3). then p2 is resolved after that.

what it tries to bring is a simplification of syntax.

Could you give an example of what you mean by the `await.all { ... }` block
> syntax bringing "complexity on returning values assignment, specially
> when" "about constants (`const`)", as I'm unclear what you are referring to
>

`const` and `let` are block-scoped, so this is referring to avoid that
block notation, and then keep coherent with the possibility to directly
infer in current scope references without extra segments / blocks.


> On Tue, 26 Nov 2019 at 13:35, manuelbarzi <manuelbarzi at gmail.com> wrote:
>
>>
>>
>>> Why not just maximally preserve current JavaScript for parallel
>>> execution, just by omitting `await` in multiple async calls, simply
>>> wrapping it in an `await.all` block to ensure completion before code
>>> continues past the block. This surely is the more straightforward way to
>>> satisfy the same goals?
>>>
>>
>> because wrapping it an `await.all` on the one hand explicitly groups
>> promises, but brings complexity on returning values assignment, specially
>> when is about constants (`const`). so, if you avoid blocks, just marking
>> parallel awaits with, for example, a suffix `await||`, or whatever other
>> more convenient way, you can just write the code in series as normally, and
>> avoid that complexity. the transpiler would just require to group the
>> consecutive marked parallel awaits (`await||`) into a Promise.all() and
>> that's it. following i reproduce the demo before:
>>
>> ```
>> // NOTE p? = function call that returns a promise (? = just and index)
>>
>> // NOTE s? = function call that runs synchronously and returns a value (? = just and index)
>>
>> const x0 = await p0()
>>
>> const x11 = s11() // sync code in-the-middle
>>
>> const x1 = await || p1(x0)
>> const x3 = await || p3(x11)
>> const x2 = await p2(x1)
>> const x10 = await p10(x2, x3)
>>
>> const x12 = s12() // sync code in-the-middle
>>
>> const x4 = await || p4(x1, x2)
>> const x5 = await || p5(x2, x3, x12)
>> const x6 = await p6(x4, x5, x10)
>>
>> const x7 = await || p7(x4, x6)
>> const x9 = await || p9(x5, x6)
>> const x8 = await p8(x6, x7)
>>
>> await p11(x8, x9)
>>
>>
>> // it would resolve a tree of parallel and series like following with traditional promises
>>
>> p0
>>     .then(x0 => {
>>         const x11 = f11()
>>
>>         return Promise.all([p1(x0), p3(x11)])
>>             .then((x1, x3) =>
>>                 p2(x1)
>>                     .then(x2 =>
>>                         p10(x2, x3)
>>                             .then(x10 => {
>>                                 const x12 = s12()
>>
>>                                 return Promise.all([p4(x1, x2), p5(x2, x3
>> , x12)])
>>                                     .then((x4, x5) =>
>>                                         p6(x4, x5, x10)
>>                                             .then(x6 => Promise.all([p7(
>> x4, x6), p9(x5, x6)])
>>                                                 .then((x7, x9) => p8(x6,
>> x7)
>>                                                     .then(x8 => p11(x8,
>> x9))
>>                                                 )
>>                                             )
>>                                     )
>>                             })
>>                     )
>>             )
>>     })
>> ```
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20191126/dca407c5/attachment.html>


More information about the es-discuss mailing list