15:58
<Rob Palmer>
Good morning, all. Plenary begins in one hour.
16:27
<rbuckton>

For those interested, I have two draft PRs up that illustrate the potential cover grammars for await using and async using:

17:18
<yulia>
slides for the awkwardly done election (sorry about that y'all) https://docs.google.com/presentation/d/1xQ7huTJQsbcfFM6nhN7Tk3uBUf3h7FHkroM1m56ueZE/edit#slide=id.g6e7d7a6a09_0_98
17:20
<ptomato>
I thought it was fine, I had no problem with the process, personally
17:21
<yulia>
ah nice, i like source as a keyword
17:22
<Michael Ficarra>
I already love this presentation
17:34
<Justin Ridgewell>
Wait, he said "next slide" right?
17:34
<Justin Ridgewell>
I'm still seeing "Import phase syntax" slide
17:34
<Chris de Almeida>
we're on spec: ordering of fetches slide
17:34
<Chris de Almeida>
now on spec: idempotence is unchanged
17:35
<Chris de Almeida>
https://docs.google.com/presentation/d/1F62Jia5erIm6m6nqkm_2pFIlNLOVF0E4ewrVRytSJEs/edit
17:48
<Michael Ficarra>
this seems like a thing that we, as language designers, would notice and/or care about, but users of the language don't want to care about this distinction or have to pass around an awkward intermediate opaque value because of it
17:49
<ryzokuken>
feature request: import/export queue as YAML
17:49
<Jack Works>

some though:

import source wasm from './x.wasm'
// and
import wasm from './x.wasm'

both give us reference to undeniable host objects.

17:50
<Michael Ficarra>
I mean that depends on the embedder, right?
17:51
<Michael Ficarra>
the embedder could add hooks for denying that, surely
17:51
<Jack Works>
yes. since it already happens today, IMO we no need to care about deniability in this syntax.
18:08
<Andreu Botella>
Wait, so import x from "test" and import x from "test" with {} would have different cache keys?
18:08
<littledan>
in that case, no
18:09
<littledan>
keep in mind, it's not that all attributes result in a differing cache key at the host level, they might be normalized just like relative paths
18:10
<Andreu Botella>
slide https://docs.google.com/presentation/d/1Abdr54Iflz_4sah2_yX2qS3K09qDJGV84qIZ6pHAqIk/edit#slide=id.g216c73c7b74_0_35 seems to suggest the cache key for the former would be #["test", null] and the latter would be #["test", #{}]
18:12
<yulia>
erm, ok. i have maybe a solution to what mark is asking
18:12
<yulia>
i have a slide deck
18:13
<yulia>
but it wasn't totally ready
18:13
<yulia>
I will probably do it as a blog post after i've had a chance to talk to the other modules folks
18:13
<Andreu Botella>
oh, I just checked the proposed spec text and it is actually the same cache key, my bad
18:14
<yulia>
here is the deck: https://docs.google.com/presentation/d/1YDFyEj8SxbWXhtPBVjyoSOVnaeydnZ_lexmd-LLgO4U/edit#slide=id.p
18:14
<yulia>
its out of date, please don't take it as anything concrete
18:15
<yulia>
I took it off the agenda because it wasn't concrete but i can talk about it briefly
18:15
<littledan>
I'd encourage you to add this to the agenda as well as the queue
18:16
<Michael Ficarra>
I think Mark was probably just unaware of the coordination already happening between the module proposal authors
18:16
<Rob Palmer>
I've been impressed with how much coordination and participation has gone into the various modules proposals
18:18
<Jesse (TC39)>
OT yulia presented some stuff about this module work (including layering/process improcements) at BOBKonf 2023 just last week (great talk!) https://bobkonf.de/2023/startsev.html
18:18
<yulia>
its very out of date already
18:19
<Jesse (TC39)>
in one week? JS moves faster than I thought!
18:19
<yulia>
yes, i have the wrong names already, probably because i was writing the talk a couple of months ago
18:19
<littledan>
I think it'd be much better to discuss this internally in TC39, even if very very unfinished, before you leave (and maybe this will feed into the blog post, even)
18:19
<littledan>
the bar for something we're discussing just internally should be logically lower than what goes into a public-facing blog post
18:22
<yulia>
my view on layering doesn't need to be adopted, its just my thinking
18:22
<ljharb>
littledan: afaik node already decided to reflag
18:23
<yulia>
and blocking that from going public is something i am against because i have reasons for my opinions even if tc39 disagrees
18:23
<bakkot>
honestly the slow path seems totally fine as long as we update docs and stuff?
18:23
<littledan>
littledan: afaik node already decided to reflag
interesting, I guess they don't need a signal from us?
18:23
<bakkot>
like if no new code uses assert, I don't see a problem
18:23
<ljharb>
interesting, I guess they don't need a signal from us?
they reflagged because they had no signal, and the future of the syntax was uncertain
18:23
<Michael Ficarra>
bakkot: it's a bit scary, you don't want to have adoption of the legacy variant increase
18:23
<Michael Ficarra>
hopefully implementations can warn through some side channel
18:24
<bakkot>
console warning would be good too yeah
18:24
<Michael Ficarra>
console warning only if mtime > March TC39 meeting lol
18:24
<littledan>
they reflagged because they had no signal, and the future of the syntax was uncertain
has a release actually gone out with the re-flagging?
18:25
<ljharb>
i don't think so yet
18:27
<eemeli>
Do we have any precedent for a MAY or SHOULD statement on emitting warnings for deprecated syntax?
18:27
<bakkot>
nope
18:27
<Michael Ficarra>
eemeli: we have no jurisdiction there
18:28
<bakkot>
we can give suggestions but like we can also give suggestions to Shu, in words
18:28
<shu>
like yes i am not a generative AI
18:30
<eemeli>
Tbf, I think we're just established that it's not just Chrome.
18:30
<bakkot>
does node ever do warnings? warnings from node can break stuff
18:30
<bakkot>
bundlers could, though
18:30
<bakkot>
I guess it does ever do warnings; I have seen some
18:31
<littledan>
and blocking that from going public is something i am against because i have reasons for my opinions even if tc39 disagrees
Sorry I did not mean that I or anyone should block you from doing anything, it just seems like you're hesitant to present something unfinished to us and I was trying to encourage you that it'd be OK to share.
18:31
<eemeli>
At least for flagged features, it does.
18:32
<Michael Ficarra>
doesn't do warnings? I have an UnhandledPromiseRejection for you
18:32
<ljharb>
node def does warnings, and has a caching mechanism so it only shows it to you once per process
18:32
<bakkot>
UnhandledPromiseRejection now crashes the process by default, I think
18:33
<Mathieu Hofman>
Where do I find the slides yulia ?
18:33
<yulia>
https://docs.google.com/presentation/d/1YDFyEj8SxbWXhtPBVjyoSOVnaeydnZ_lexmd-LLgO4U/edit#slide=id.p
18:33
<yulia>
its not that much of an evolution of what we've discussed in the module calls
18:33
<yulia>
you will notice things are on different layers and the layers are named
18:34
<yulia>
its in part in response to my thinking of how the layers can be organized
18:39
<danielrosenwasser>
Are there any annex features that don't run on all major browsers?
18:39
<danielrosenwasser>
(I swear I am not trying to start a fight πŸ˜…)
18:40
<ryzokuken>
editorial notes could help?
18:40
<shu>
this is a spectacularly unnuanced understanding of the purpose of a specification document
18:41
<nicolo-ribaudo>
Are there any annex features that don't run on all major browsers?
This would not be annex b -- annex b must be implemented by all browsers
18:41
<ryzokuken>
I mean, we could include it with a big banner that says "careful"
18:41
<Jack Works>
This would not be annex b -- annex b must be implemented by all browsers
annex b + normative optional πŸ˜‚
18:41
<danielrosenwasser>
ah, I see. I'm just trying to understand better.
18:42
<eemeli>
Annex C, anyone? πŸ˜‡
18:42
<shu>
it is fine if committee wants the lesson V8 to learn from this is "conformance as a proxy measure for shipping reality becomes even more tenuous"
18:42
<shu>
but that will weaken TC39's pull in the future, to be clear
18:43
<ljharb>
i'm confused. why would supporting assert syntax make you noncompliant?
18:43
<ljharb>
the spec already explicitly allows implementations to go nuts with their own syntax
18:43
<bakkot>
speaking of, I still need to specify the if (false) f() = 0 syntax...
18:44
<bakkot>
ljharb: I do not think we want implementations to think of themselves as being allowed to go nuts with their own syntax, regardless of whether the spec says they are allowed to
18:44
<ljharb>
i very much wouldn't want to make important implementations noncompliant, but omitting assert from the spec doesn't seem like it would cause that.
18:44
<ljharb>
ljharb: I do not think we want implementations to think of themselves as being allowed to go nuts with their own syntax, regardless of whether the spec says they are allowed to
very true
18:44
<shu>
it is no skin off my back to start going nuts with syntax
18:44
<littledan>
it is fine if committee wants the lesson V8 to learn from this is "conformance as a proxy measure for shipping reality becomes even more tenuous"
I don't think V8 should take that lesson; it was clear that the committee largely does see the spec reflecting reality as a goal.
18:44
<shu>
but more narrowly, because the spec needs to say assert has the same semantics as with
18:44
<ljharb>
i see that as a goal as well. but it has a purpose beyond that in that it guides new implementations
18:45
<shu>
that's what the "legacy" box is for
18:45
<shu>
that is literally why that box exists
18:45
<ljharb>
sure. but that's for stuff that all browsers already implement. this one's just chrome
18:46
<bakkot>
Legacy is actually "must implement"
18:46
<shu>
sorry, normative optional + legacy
18:46
<bakkot>
but Legacy plus Normative Optional does the thing yes
18:46
<ljharb>
maybe the solution is to invent a new category that's more strongly worded and implies both legacy and normative optional, i dunno
18:46
<Jack Works>
can we try? maybe the migration isn't that hard considering code using import assertions are new and highly likely in maintaining
18:46
<ryzokuken>
odd sidebar, since I'm curious: is it a possibility to eventually move Date to this "legacy" section?
18:47
<ljharb>
but there is a distinct difference to me between the string HTML methods, and the assert syntax
18:47
<littledan>
odd sidebar, since I'm curious: is it a possibility to eventually move Date to this "legacy" section?
no? this is a confusing tangent
18:47
<ryzokuken>
yes, sorry
18:47
<ljharb>
seems very unlikely
18:47
<Andreu Botella>
Legacy + Normative Optional + Pls Do Not Ship If At All Possible
18:47
<Jack Works>
you can mark anything as deprecated if you want, but just don't remove it
18:49
<Jack Works>
wonder the real world use rate in Web of Import assertions
18:49
<Jack Works>
is there any data of it?
18:49
<Jesse (TC39)>
wonder the real world use rate in Web of Import assertions
I think yulia might have some data there?
18:49
<HE Shi-Jun>
wonder the real world use rate in Web of Import assertions
I believe it's very low
18:50
<yulia>
chrome would be the one with the counters
18:50
<justinfagnani>
it has to be very, very low
18:50
<Jack Works>
I think yulia might have some data there?
but firefox does not ship it?
18:50
<yulia>
at the moment, no
18:50
<yulia>
we have an implementation but it is unshipped
18:51
<yulia>
safari likewise has it behind a flag
18:51
<ljharb>
it would be a really unfortunate outcome imo if anyone newly ships it unflagged (prior to time + evidence that it's unshakeable web reality)
18:51
<yulia>
i believe assert is most used by tooling, Justin Ridgewell would have the context here
18:51
<ljharb>
and given how new this feature is, it seems entirely achievable for everyone using assert to migrate to with
18:52
<bakkot>
eventually
18:52
<ljharb>
sure, in the fullness of time. but i think on a reasonably short timescale
18:52
<ljharb>
if every browser, and node/deno, shipped with today, i'd expect assert to be largely gone in like a year
18:52
<justinfagnani>
the most likely usage is in v8-only environments: Deno, Node, Electron, etc... but those are versioned and also have breaking changes somewhat regularly
18:54
<Jack Works>
(IIRC some linux let apps use shared electron so maybe for electron it's not so versioned)
18:54
<justinfagnani>
v8 use counters would need to differentiate web from server (if any server env even contributes to use counters, which I doubt?)
18:54
<ljharb>
p sure use counters are in chrome, not v8?
18:54
<justinfagnani>
ah, counter would be web-only
18:54
<shu>
yeah that use counter infra is chrome only i think
18:55
<bakkot>
node's ability to ever ship breaking changes is great, I love that; I also appreciate that it happens quite rarely these days
18:55
<Jack Works>
does Electron has use counter?  πŸ§
18:55
<bakkot>
I have not had an issue updating a major version of node since 10->12
18:55
<justinfagnani>
I don't know... seems like some sort of metrics would have been useful from server / desktop environments, but I admit I don't know of any that do
18:55
<shu>
this is just the consequence of our staging and shipping model
18:55
<shu>
you can't have your cake and eat it too
18:56
<shu>
i am not interested in spec purity
18:56
<Jack Works>
node's ability to ever ship breaking changes is great, I love that; I also appreciate that it happens quite rarely these days
(Node 18 new SSL provider breaks Webpack 4)
18:56
<bakkot>
fortunately webpack is usually a direct dep rather than a transitive dep, so that's not too bad
18:58
<Jack Works>
if we're interested in spec purity, we won't have IsHTMLDDA today
18:58
<ljharb>
unfortunately tho, lots of people can't upgrade to webpack 5 because of its node core module polyfilling change, so unless a fix is backported to v4 lots of people will be stuck
18:59
<Michael Ficarra>
ljharb: I would prefer the committee not give too much editorial direction here. I want to retain discretion to best communicate what we understand the committee's opinion to be here.
18:59
<Jack Works>
that one is easy to migrate. the hard part is webpack plugins and loaders
19:00
<bakkot>
this sounds like "deprecated" to me
19:00
<shu>
also sounds like deprecated to me
19:00
<ljharb>
ljharb: I would prefer the committee not give too much editorial direction here. I want to retain discretion to best communicate what we understand the committee's opinion to be here.
yeah i'm not trying to dictate editorial wording, just the conveyed intent
19:01
<littledan>
+1 to Jordan's comments about the spec being explicit about the hope to remove it (though I'd note that normative-optional advocates like to think the same thing about those sections)
19:01
<msaboff>
Annex B is evidence that we don't have spec purity. I'd rather that we don't decrease purity.
19:02
<shu>
that's fair, but the bar for me for when it's acceptable to decrease purity is "is this true of the world", not "is this a wish we have of the world"
19:02
<shu>
and as i said we can find that out empirically
19:03
<bakkot>
I am real curious what the real-world in-browser usage will turn out to be
19:03
<shu>
yeah
19:03
<littledan>
Annex B is evidence that we don't have spec purity. I'd rather that we don't decrease purity.
msaboff: What do you think about the point Shu made of, this committee will have more influence if we are willing to be impure in this way?
19:04
<shu>
corollary: be careful how many times you ask people to unship
20:03
<rbuckton>

For those interested, I have two draft PRs up that illustrate the potential cover grammars for await using and async using:

20:04
<rbuckton>
Rendered version of #15 (await using): https://tc39.es/proposal-async-explicit-resource-management/pr/15
Rendered version of #16 (async using): https://tc39.es/proposal-async-explicit-resource-management/pr/16
20:06
<rbuckton>
Apologies, I need to step out for a few minutes. I will be back shortly.
20:06
<msaboff>
ljharb: Where would I find the draft standard for patent opt out review?
20:07
<littledan>

Draft notes for the conclusion for import attributes, please edit the notes if you want to refine anything:

Summary

Import attributes are the path forward for the standard, having re-achieved Stage 3.
The keyword is with
As previously, there is an options bag following it
The options can form part of the interpretation of the module and "cache key"
Unknown attributes in the import statement cause an error.
Although a couple delegates would prefer sticking with the keyword assert, the majority preferred switching to the long-term optimal solution of being more semantically well-aligned using with
Significant debate focused around how to communicate the deprecation.

Conclusion

assert will remain in the specification, marked somehow as "deprecated", with the intention to remove it eventually, though with an anticipated timespan of at least multiple years before final removal.
JS environments which currently ship assert are not encouraged to remove it, but environments which do not yet ship assert are discouraged from shipping it.
Chrome will gather data on usage of assert on the web, which can inform the deprecation path.
Conditional consensus for Stage 3 on this proposal, with the conditions:
Reviews are still needed from the reviewers who volunteered – JRL and JHD, as well as the editors
The wording for normative optional+legacy needs to be updated to something stronger, probably "deprecated", and explaining the goal to remove it from the specification.

20:08
<ljharb>
ljharb: Where would I find the draft standard for patent opt out review?
it hasn't been produced/cut yet, so for now you can look at https://tc39.es/ecma262, but i'll create a github release on the spec repo, and a Reflector issue, and i'll post it in here, when it's prepared
20:08
<shu>
yeah, i think tip-of-tree right now will get tagged
20:09
<msaboff>
yeah, i think tip-of-tree right now will get tagged
Can you or another editor email me when it is tagged?
20:10
<shu>
sure, let me make a reminder
20:10
<Michael Ficarra>
I would phrase that as: the draft is final, is currently at https://tc39.es/ecma262, but will soon be available at the more stable URL https://tc39.es/ecma262/2023/
20:12
<msaboff>
Michael Ficarra: When do you think the stable URL will be available?
20:12
<bakkot>
I actually did not know until looking at this issue that python's range does not allow non-integer values, which I think is indicative of how rarely it comes up (at least in the kind of code I tend to write)
20:13
<shu>
were floating point use cases the champion considers compelling presented?
20:13
<msaboff>
Seems like integer only makes a lot of sense.
20:13
<shu>
i am not understanding who is advocating for floats
20:14
<shu>
(tab is not here)
20:14
<bakkot>
tab advocated non-integers, hax opposed; we are here to find out what the committee as a whole things
20:14
<bakkot>
more people need to express opinions
20:14
<shu>
but are there use cases?
20:14
<shu>
my intuition is strongly integer only
20:15
<shu>
like... why are you doing 0, 0.3, 0.6, 0.9?
20:17
<rbuckton>
For reference, Python's range() doesn't allow floats.
20:19
<shu>
from https://github.com/tc39/proposal-Number.range/issues/64, tab says: "Ranges that include floating-point numbers are perfectly fine and reasonable, and people will want to do them - if we arbitrarily restrict it from this API people will just write their own and be justifiably angry at us for screwing up the API and forcing them to reinvent it themselves."
20:19
<shu>
but... really?
20:19
<bakkot>
I found the linked stackoverflow question about python's range informative: https://stackoverflow.com/questions/477486/how-do-i-use-a-decimal-step-value-for-range
20:20
<shu>
what's your take from that SO question?
20:20
<bakkot>
people aren't mad about it, basically
20:21
<shu>
mine is "if we restrict it, people will ask, and be told how to do it correctly, instead of being mad and also doing it wrong"
20:21
<shu>
okay i think that matches with mine
20:21
<bakkot>
or like, reasonable people can give a good answer to the question that is not just "this is a bug"
20:21
<shu>
right
20:21
<bakkot>
possibly some people are mad about it somewhere but clearly not everyone
20:21
<shu>
i don't know how you can be mad at "hold on now, have you heard about rounding errors"
20:22
<bakkot>
oh I'm mad about that, but in the way that I am mad about entropy, not the way that I am mad about idk strings being utf-16 or whatever
20:22
<Michael Ficarra>
I bet most JS programmers don't even know what a float is, and just treat JS numbers as if they were reals
20:23
<Michael Ficarra>
they don't want to hear about rounding errors
20:23
<bakkot>
well if range() doesn't allow floats then they won't have to
20:23
<bakkot>
if they put floats in range then they will have to learn about them
20:24
<eemeli>

I found it interesting that these "fail" in slightly different ways:

> for (let i = 0; i < 10; i += 1) console.log(i * 0.1)
0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6000000000000001
0.7000000000000001
0.8
0.9

> for (let i = 0; i < 1; i += 0.1) console.log(i)
0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
20:24
<bakkot>
(to be clear I'm just repeating things Hax already put in the issue, not finding things myself)
20:26
<bakkot>
ljharb: when we say "disallow floats" everyone means "disallow non-integer numbers"
20:26
<bakkot>
no one is suggesting not allowing integral floats
20:27
<bakkot>
though there is some question about whether to allow numbers above max-safe-int
20:29
<Michael Ficarra>
yes I wish we would stop saying "disallow floats", it is confusing people
20:33
<bakkot>
to be clear, this is also how floats work in python; that's how floats work in every language. but python disallows non-integer floats in range, and that's fine
20:33
<bakkot>
so it clearly is a thing that a language can choose to do
20:34
<shu>
no the lack of use cases is specifically about range
20:34
<shu>
not about floating point numbers
20:35
<mpcsh>
Willian Martins your name isn't in the delegates list for the notes β€” is your acronym WMS? https://github.com/tc39/notes/blob/main/delegates.txt
20:35
<mpcsh>
(also please send a PR to add yourself to that at your leisure)
20:35
<Jack Works>
consistency vs foogun prevention
20:36
<Jack Works>
πŸ₯²
20:36
<Willian Martins>
yes
20:36
<ljharb>
see also, the this argument on array methods
20:37
<Michael Ficarra>
I see their name in the notes
20:41
<Justin Ridgewell>
Is the current proposal with add or multiply semantics?
20:42
<ljharb>
multiply iirc
20:43
<Michael Ficarra>
multiply
20:43
<Justin Ridgewell>
start + (step * currentCount) perfect
20:44
<Justin Ridgewell>
Had to scan the spec for a min
21:00
<Michael Ficarra>
I agree with Shu's point that we should probably align with wasm on whether they add an f16 for these or they get promoted when they cross to wasm
21:01
<mpcsh>
Willian Martins your name isn't in the delegates list for the notes β€” is your acronym WMS? https://github.com/tc39/notes/blob/main/delegates.txt
dminor you as well β€” I see DLM in the notes, please add yourself to the list πŸ™‚
21:02
<Michael Ficarra>
Dan is also in the list already
21:02
<Michael Ficarra>
mpcsh: I think your search is broken
21:03
<mpcsh>
you're right β€” I don't know how I missed Willian. I searched for "Daniel Minor" though here. I see them both now!
21:17
<Justin Ridgewell>
Someone is being very loud in front of a mic
21:18
<Chris de Almeida>
aggressive clicking
21:18
<Luca Casonato>
Is this still the case Justin Ridgewell?
21:18
<Justin Ridgewell>
No
21:18
<Justin Ridgewell>
Sorry, yes
21:18
<Justin Ridgewell>
Still noisy
21:18
<Luca Casonato>
clicking or keyboard?
21:18
<Chris de Almeida>
both
21:19
<Justin Ridgewell>
Clicking?
21:19
<ljharb>
from the room or the call? the room i assume
21:19
<Justin Ridgewell>
Also shuffling
21:19
<Chris de Almeida>
yes?
21:19
<Michael Ficarra>
I don't hear this noise from the room
21:19
<Rob Palmer>
in the room we do not hear aggressive typing or clicking
21:19
<Chris de Almeida>
good now
21:20
<shu>
isn't that a strawperson
21:21
<shu>
like these arguments are formed like "it's impossible to express now", whereas it's more like "we have to use libraries"?
21:22
<shu>
the last bullet point is about accidental casts which i remember littledan and brendan bringing up years ago
21:22
<shu>
that one seems legit as an argument for language inclusion over library
21:31
<bakkot>
anyone know why IEEE decimal distinguishes between 1.2 and 1.20?
21:31
<Michael Ficarra>
sigfigs?
21:31
<littledan>
like high school science
21:32
<littledan>
anyone know why IEEE decimal distinguishes between 1.2 and 1.20?
this page explains at way too much length: https://speleotrove.com/decimal/decifaq.html
21:32
<littledan>
there are many use cases posited there for trailing zeroes. The author of this document was participating in the IEEE process.
21:32
<bakkot>
oh boy
21:33
<littledan>
it is actually a fun and well-written piece
21:35
<Michael Ficarra>
last updated today, wow
21:35
<bakkot>
no it just has some JS that writes the current date
21:35
<bakkot>
I was also confused by that
21:35
<Michael Ficarra>
well that is very weird
21:36
<ljharb>
lol that was a common practice in the late 90s
21:36
<ljharb>
next to a "visit counter"
21:36
<bakkot>
actually it appears to be using document.lastModified
21:36
<bakkot>
which, TIL
21:36
<ljharb>
huh
21:38
<Rob Palmer>
Feedback from remote attendees is that the room mic is particularly hot where Jordan and Patrick are sitting. We hear clicks and zipping noises, etc. Just for awareness.
21:40
<shu>
actually it appears to be using document.lastModified
wow how does it know? whatever the server says i guess?
21:41
<Michael Ficarra>
shu: I think it only works for local files
21:41
<Michael Ficarra>
maybe it goes off a response header though, I dunno
21:42
<bakkot>

The Document's source file's last modification date and time must be derived from relevant features of the networking protocols used, e.g. from the value of the HTTP Last-Modified header of the document, or from metadata in the file system for local files. If the last modification date and time are not known, the attribute must return the current date and time in the above format.

21:42
<bakkot>
https://html.spec.whatwg.org/multipage/dom.html#dom-document-lastmodified-dev
21:42
<shu>
sick
21:43
<littledan>
My point was going to be: I think the more important reason (than performance) for decimal over rational is, the very core and common operation of rounding makes sense for decimals in a way which is a sort of mismatch for rationals. This is very common in financial calculations, to have well-defined rounding of intermediate values.
21:44
<shu>
+1 to dminor
21:45
<littledan>
I can understand "it's not motivated enough" or "it's too much work to implement" as counterarguments, but "there is a design space" is a common attribute of just about everything we do in TC39.
21:46
<littledan>
Utility as something built-in here is analogous to something like Temporal--it ends up being useful to have some things built-in sometimes. I think this is about the use cases being persuasive enough to pay for the complexity and implementation cost, which maybe we haven't shown.
21:47
<shu>
in retrospect Temporal should have been a blessed library
21:47
<shu>
(IMO)
21:47
<apaprocki>
we don't have a way to do that though
21:47
<Michael Ficarra>
nah, date/time handling is provided (usually poorly) in almost all std libs
21:47
<apaprocki>
interchange is the thing that kills us by not having a vocabulary type
21:47
<Michael Ficarra>
tzdata is live as well
21:48
<shu>
what is a vocabulary type again
21:48
<apaprocki>
literally every single software product/language that exists has decimal, so making NxM products all flow through JS is burdensome
21:48
<littledan>
like, if we have something built-in, then all the different libraries know that they can use it. This comes up for Promises, Temporal, Decimal, and more
21:48
<shu>
"vocabulary type" means "built-in"?
21:49
<apaprocki>
vocabulary meaning, a concept of interchange between languages/systems
21:49
<apaprocki>
even within the same language/system
21:49
<shu>
okay
21:49
<apaprocki>
so double in C++ / number in JS
21:49
<shu>
i will be unequivocal about one thing, which is what i was planning to bring in the queue: V8 is not going to be okay with a new value type
21:49
<littledan>
i will be unequivocal about one thing, which is what i was planning to bring in the queue: V8 is not going to be okay with a new value type
I would really like to have this conversation in plenary in the overflow time
21:50
<shu>
sure
21:50
<apaprocki>
yes, that was the path that was being suggested
21:50
<apaprocki>
path being (not a value type)
21:50
<shu>
well, waldemar brought up === overloading
21:50
<shu>
which is also not something V8 wants
21:50
<Michael Ficarra>
yes, I disagree with that point made by waldemar
21:50
<littledan>
well, waldemar brought up === overloading
yeah, this is exactly why I'm looking forward to having a conversation about it together (as opposed to isolated points from individuals)
21:51
<apaprocki>
if we could scope/timebox an overflow specifically about this, it would really help inform champions
21:51
<apaprocki>
assuming an object w/o overloading is being proposed, what are delegate opinions as to why that would not be acceptable
21:52
<littledan>
assuming an object w/o overloading is being proposed, what are delegate opinions as to why that would not be acceptable
Yeah, I think we could divide the discussion into those two parts (I'd also like to discuss why Waldemar wants overloading, and what others think about this topic)
21:52
<Michael Ficarra>
the timebox was just not big enough, we had a ton more to talk about wrt decimal
21:53
<littledan>
the timebox was just not big enough, we had a ton more to talk about wrt decimal
Good thing we have tons of slack time this meeting.
21:54
<Rob Palmer>
the slack is being consumed at a fast rate
21:55
<Rob Palmer>
we are down to 25mins remaining
21:57
<rbuckton>

I'll be honest, I'd love something a regex tagged template for x-mode, but I'd be more likely to want to bring prefix modifiers back for something like:

const re = RegExp`(?x)
# comments
multi|line
regexp
`;

as I'm also not a fan of having to nest ` and /.

21:59
<Luca Casonato>
MSL's library that Mark is referring to: https://github.com/mikesamuel/regexp-make-js
22:03
<rbuckton>
I think one of Mark's concerns about string append is character classes. If Regexp.escape is safe for new RegExp("[" + Regexp.escape(input) + "]"), is that still a concern?
22:04
<Richard Gibson>
also backslash: https://github.com/tc39/proposal-regex-escaping/issues/37#issue-98309281
22:04
<littledan>
I don't understand jridgewell's point
22:05
<HE Shi-Jun>
I think one of Mark's concerns about string append is character classes. If Regexp.escape is safe for new RegExp("[" + Regexp.escape(input) + "]"), is that still a concern?
how it could be safe?
22:05
<Justin Ridgewell>
re``` is just invalid
22:06
<rbuckton>
how it could be safe?
Every character can be escaped into something that would be valid in a ClassAtom
22:06
<Justin Ridgewell>
You can't match a ` in a TTL built RegExp
22:06
<Justin Ridgewell>
Because you can't have a lone ` in a TTL
22:06
<littledan>
I don't understand why re` or `re`\\ wouldn't work for this
22:06
<littledan>
(ugh how do I type that?0
22:06
<waldemar>
anyone know why IEEE decimal distinguishes between 1.2 and 1.20?
It's just that, unlike IEEE binary which always has an implied 1 as the leading mantissa digit for non-denorms, there are multiple bit patterns that can represent the same IEEE decimal number because the leading mantissa digit can be 0 through 9. For example, there are hundreds of ways to represent +0 as a IEEE decimal, and they're all different and distinguishable.
The situation is similar to how UTF-8 was originally defined: there were multiple ways to encode "a" (either as a single byte, as two bytes, as three bytes, etc.). Eventually this became enough of a problem that UTF-8 was changed to ban encodings other than the shortest possible ones.
22:06
<Justin Ridgewell>
Because the \ is now included in your regex
22:07
<rbuckton>
You can't match a ` in a TTL built RegExp
You can, but not easily. You would have to do RegExp`${"`"}`, which isn't ideal but it is feasible.
22:07
<Justin Ridgewell>
I want to match "`"
22:07
<Justin Ridgewell>
But that won't work for \
22:07
<rbuckton>
I don't understand why re` or `re`\\ wouldn't work for this
double backtick (or one more than the number used in the sample)
22:07
<rbuckton>
i.e., `` ` `` produces `
22:07
<Justin Ridgewell>
Because \ is a special char in RegExp that would need to be escaped in the expression form
22:08
<Justin Ridgewell>
If we had the re``` ``` multitick start/stop form from String.dedent, then it would have worked except for \
22:09
<rbuckton>
We can have re``` ```
22:09
<rbuckton>
But it doesnt do what you want :)
22:09
<Michael Ficarra>
lol yeah we already have that rbuckton
22:09
<Justin Ridgewell>
Yah, this got brought up during String.dedent unfortunately
22:10
<Michael Ficarra>
Justin Ridgewell: I still don't see how ``re```` doesn't do what you want
22:10
<Michael Ficarra>
jesus
22:10
<Michael Ficarra>
I don't know how to talk about this
22:10
<HE Shi-Jun>
even u have ``` ```, what if u want to match ``` ?
22:10
<Justin Ridgewell>
Tip, matrix supports multitick blocks
22:10
<ljharb>
`
22:10
<Michael Ficarra>
re`\\\`
22:10
<Michael Ficarra>
there
22:10
<Justin Ridgewell>
``` delimits with 4 ticks at start/stop
22:10
<littledan>
Kleene's regex language, I imagine Mark is referring to
22:11
<rbuckton>
re`\\\`
/\/ doesn't work either though
22:11
<shu>
i've always pronounced that Clean-y
22:11
<Michael Ficarra>
omfg
22:11
<shu>
is it actually Clean?
22:11
<Michael Ficarra>
yes I am trying to write two backslashes
22:11
<littledan>
is it actually Clean?
my theory-heavy coworker pronounced its Clean-y the other day
22:11
<Justin Ridgewell>
/\/ doesn't work either though
That would be written as /\\/ to match s = "\\"
22:11
<Justin Ridgewell>
But it's not possible to write with a TTL
22:12
<Michael Ficarra>
Justin Ridgewell: please explain why not
22:12
<Justin Ridgewell>
re`\` is invalid syntax
22:12
<rbuckton>
Yeah, though your comment indicates that \ in a RegExp template is impossible, when it seems pretty consistent with RegExp literals
22:12
<Justin Ridgewell>
And re`\\` only matches s = "\\\\"
22:12
<shu>
we're on break now right?
22:12
<eemeli>
Yes.
22:12
<rbuckton>
I agree that ` is problematic, but also rare.
22:13
<Justin Ridgewell>
String.raw`\\`.length === 2, not 1
22:13
<rbuckton>
Yeah, that's fair. raw is a bit weird, though I wonder if that case is possible to detect.
22:14
<Michael Ficarra>
re`\` is invalid syntax
two backslashes
22:14
<rbuckton>
i.e., Treat \\ as \ when parsing from a tagged template literal
22:14
<Justin Ridgewell>
See https://matrix.to/#/!WgJwmjBNZEXhJnXHXw:matrix.org/$aLh1spEECiImadJ_R3hX7vmWq_x53QWJ5RoJwgTztV4?via=matrix.org&via=igalia.com&via=mozilla.org
22:15
<Justin Ridgewell>

And re`\\` only matches s = "\\\\"

22:16
<rbuckton>

And re`\\` only matches s = "\\\\"

Yes, could we not detect that case when parsing from a template tag?
22:16
<Justin Ridgewell>
/`/ and /\\/ cannot be represented
22:17
<rbuckton>
I think /\\/ can be handled. /`/ can't
22:33
<Rob Palmer>
Asumu is primarily addressing the feedback that we ought to explore whether runtime-types should be in-scope.
22:44
<Michael Ficarra>
for proponents of runtime types, what do you expect an engine to do if the declared type is incorrect and an engine optimises based on that type? is it now permitted to have a different result? UB?
22:44
<Justin Ridgewell>
eemeli ljharb I think Asumu is addressing runtime vs compile time in this presentation, and not unification.
22:45
<ljharb>
feel free to move mine to the end of the list, but i still want to bring it up if there's time
22:47
<eemeli>
Same, because this proposal continues to focus on the technical details of a specific solution, and not addressing their stated main goal.
22:47
<Justin Ridgewell>
Ok
22:48
<Justin Ridgewell>
I agree that this is an important topic for the overall proposal, just not sure if he's prepared to address them
22:48
<littledan>
Please feel free to ask these kinds of big-picture questions; they seem important at this stage
22:48
<danielrosenwasser>
I'm prepared to address it provided we have time, but would encourage that we focus on the current topics
22:49
<eemeli>
Part of what I'll want to say I already filed as an issue: https://github.com/tc39/proposal-type-annotations/issues/171
22:50
<Chris de Almeida>
agree -- folks should be heard, but I think it's reasonable to let folks comment on the presentation topic first. especially as this is not moving for advancement
22:52
<rbuckton>
I'm personally less interested in "unforking" or "unification", but more interested in cutting down development time by avoiding a compile step to get from writing code to running code faster.
22:53
<Michael Ficarra>
there have been some truly excellent presentations at this meeting!
22:53
<Michael Ficarra>
puts me to shame
22:53
<Michael Ficarra>
I am going to need to put more effort into mine in the future now
22:53
<eemeli>
rbuckton: Agreed. But that's not what's presented as the proposal's motivation.
22:54
<eemeli>
And it's not a part of the problem statement that was accepted a year ago.
22:55
<Rob Palmer>
I think it was part of the problem statement - we talked about the developer friction
22:55
<ryzokuken>
100% this
22:55
<Chris de Almeida>
unrelated: I am unlikely to be able to attend the end of the day. Ashley Claymore IBM supports stage 1 for await dictionary
22:55
<ryzokuken>
we need to talk about unrealistic standards about presentations in TC39 /s
23:04
<shu>
...are people talking about contracts vs types now?
23:04
<shu>
like those are different paradigms
23:05
<Michael Ficarra>
shu: ever heard of gradual typing? checkmate
23:05
<shu>
my brother...
23:05
<littledan>
shu: ever heard of gradual typing? checkmate
TypeScript is gradually typed because you can declare some types and not others!!
23:06
<shu>
lol
23:06
<littledan>
No, seriously, given the diversity of meanings of gradual typing (where people unironically use the above form), we deliberately omitted it from this presentation
23:06
<littledan>
Asumu's PhD thesis was on sound gradual typing in Racket (he cited it in the talk!)
23:07
<Rob Palmer>
yes - when Asumu said there was material on the subject he was referring to his own paper
23:07
<littledan>
tl;dr you might be able to use some fancy compiler techniques to make sound Scheme type enforcement not have way too much of a performance penalty (though it breaks down for JS, as Asumu explained)
23:08
<Michael Ficarra>
No, seriously, given the diversity of meanings of gradual typing (where people unironically use the above form), we deliberately omitted it from this presentation
people actually do this? what?
23:08
<Justin Ridgewell>
9min remaining!
23:08
<littledan>
people actually do this? what?
It is the predominant meaning in our community
23:12
<waldemar>
I don't understand DE's claim that all the things we've been adding to the language since ES6 are "unifying" the language.
23:14
<Justin Ridgewell>
We have 3 min remaining on this item
23:22
<Michael Ficarra>
is there seriously no [NLTH] in the proposed grammar?
23:22
<Justin Ridgewell>
Is this only concerned with < stuff here > syntax?
23:23
<Michael Ficarra>
requiring balanced braces would also probably be a good minimum bar
23:23
<HE Shi-Jun>
is there seriously no [NLTH] in the proposed grammar?
NLTH means "no line terminator" ?
23:23
<Michael Ficarra>
HE Shi-Jun: yes
23:24
<littledan>
I don't understand DE's claim that all the things we've been adding to the language since ES6 are "unifying" the language.
If I said "all", then that was misspeaking by me; I do think it's been a big theme in our work.
23:24
<HE Shi-Jun>
Michael Ficarra: So type is complex and seems need line terminators.
23:24
<littledan>
Even when we add things to the standard library like Array.prototype.group or Temporal, we're unifying the ecosystem where previously people had to use various different libraries to get that functionality.
23:24
<littledan>
this is sort of the normal flow of work for a standards body, I think
23:25
<eemeli>
littledan, danielrosenwasser : Is the big-picture vision that you talked about presented in text anywhere? I think that's the sort of motivation and explanation that I'm most missing here, because I don't see how type annotations can get us from here to there.
23:25
<rbuckton>
{ a: b } => can't be an arrow function or arrow type? I would expect {} to be far more limited than () and [], at least.
23:26
<rbuckton>
Also, this foo < a ; is addressed by the "turbofish" syntax ::<>, i.e. foo::< a
23:26
<littledan>
is there seriously no [NLTH] in the proposed grammar?
Yeah, fundamentally you don't get into this general token soup space without a paren, so you just have space for a token, or one of the productions that's explicitly there
23:28
<littledan>
littledan, danielrosenwasser : Is the big-picture vision that you talked about presented in text anywhere? I think that's the sort of motivation and explanation that I'm most missing here, because I don't see how type annotations can get us from here to there.
It's fine to ask us to clarify the explainer more, and I'd be happy to talk with you in more detail about how/where our current readme or presentation fails to make this case. At the same time, I'm a bit offended by the implication that the champion group doesn't know what it's trying to get at, just because the documents weren't written in a way which was sufficiently clear/persuasive to everyone.
23:34
<Justin Ridgewell>
1min
23:37
<littledan>
Does anyone know what the issue numbers that Waldemar is referring to?
23:37
<danielrosenwasser>
Unfortunately, people keep saying "turbofish", so I'll clarify that that means ::<...>
23:38
<rbuckton>
Yes, sorry. "turbofish" is the term used in Rust, per: https://blog.rust-lang.org/2021/09/09/Rust-1.55.0.html#dedication
23:38
<shu>
what is ordinary fish
23:38
<danielrosenwasser>
littledan, danielrosenwasser : Is the big-picture vision that you talked about presented in text anywhere? I think that's the sort of motivation and explanation that I'm most missing here, because I don't see how type annotations can get us from here to there.

https://devblogs.microsoft.com/typescript/a-proposal-for-type-syntax-in-javascript/#whats-next

This isn’t a sure-fire thing – there are many valuable perspectives within the committee, and we do expect some amount of skepticism. A proposal like this will receive a lot of feedback and appropriate scrutiny. It may involve lots design changes along the way, and may take years to yield results.

But if we pull this all off, we have the chance to make one of the most impactful improvements to the world of JavaScript. We’re excited by that, and we hope you are too.

23:39
<Michael Ficarra>
><>?
23:39
<littledan>
shu: We've seen TS make tricky transitions before, e.g., with class fields. I'm not really sure what more details would make sense at this stage.
23:39
<littledan>
shu: Maybe you could be more concrete with what kind of thing you're looking for?
23:40
<scottwhittaker>
Waldemar's slides are at https://docs.google.com/presentation/d/1TLGdvGfOn2wl-_i_HfrfpgFkdffrhCnisowdkOiebB8/edit#slide=id.g21db78ad531_0_44 ; the two linked issues are https://github.com/tc39/proposal-type-annotations/issues/116 and https://github.com/tc39/proposal-type-annotations/issues/103
23:40
<shu>
littledan: how did manage the transition with class fields? are old style class fields no longer supported?
23:40
<danielrosenwasser>
--useDefineForClassFields
23:41
<danielrosenwasser>
it is turned on as soon as your output --target is esWhateverVersionTheyGotStandardized
23:41
<shu>
do both kind of fields code exist in the wild and will continue to exist?
23:42
<littledan>
The class fields transition is significantly harder, because it's different semantics for the same syntax. This is just a syntax subset, completely statically visible with no ambiguity as to how it should run.
23:42
<littledan>
Until decorator metadata is standardized and adopted, set-based fields need to keep existing, unfortunately. I'm glad we're finally getting there.
23:42
<ljharb>
sffc: await.all is proposing syntax to match the existing API, not syntax instead, to be clear
23:43
<Rob Palmer>
(Responsible) evolution of TypeScript is in some ways easier than evolving JS because it's already accepted that regular upgrades of TypeScript are mild (responsibly managed) breaking changes. People accept this and spend effort upgrading. The benefits are worth it.
23:43
<danielrosenwasser>
I think the framing is partially about transitions, it's about "can we find tasteful alternatives to express the same concepts"
23:43
<ljharb>
shu: function call params are already solved because you can pass and return an object :-p
23:43
<shu>
and so this is also already solved by writing your own code?
23:44
<rbuckton>
Another example might be TypeScript's type cast syntax. We've always had <T>value, but added value as T to avoid ambiguity with JSX/TSX. We may never fully move everyone to value as T, but most TS code I see today uses as.
23:44
<ljharb>
for a function you author, yes. not for Promise combinators (at least, not without a mildly complex helper function)
23:44
<shu>
rbuckton: i don't define non-divergence by "most code don't diverge", but by "no code diverges"
23:45
<ljharb>
HE Shi-Jun: re your queue item, what does async let do exactly in swift?
23:45
<danielrosenwasser>
I think the framing is partially about transitions, it's about "can we find tasteful alternatives to express the same concepts"

so type arguments on invocations - we prefer the existing syntax, but

  1. they're rarely specified, and typically inferred
  2. Rust (everyone's new favorite language) has shown that people are fine with something like `f::<T, U>(...)
23:45
<HE Shi-Jun>
not easy to explain in one sentence
23:45
<justinfagnani>

I would rather see syntax here... like:

await const {
  shape = getShape(),
  color = getColor(),
  mass = getMass(),
};
23:45
<bakkot>
ljharb: https://www.avanderlee.com/swift/async-let-asynchronous-functions-in-parallel/
23:46
<ljharb>

I would rather see syntax here... like:

await const {
  shape = getShape(),
  color = getColor(),
  mass = getMass(),
};
imo that seems like a great followon after it already exists as API
23:46
<bakkot>
it's neat but doesn't translate naturally to JS
23:46
<danielrosenwasser>
so new code can use the ::<> syntax in TS, use the old syntax in TS, and in JS you'd have to pick one
23:46
<shu>
yes, and now you have diverged...?
23:46
<ljharb>
it's neat but doesn't translate naturally to JS
kind of seems like "just don't await the promise until later"?
23:46
<bakkot>
yyyyeah kinda
23:46
<littledan>
rbuckton: i don't define non-divergence by "most code don't diverge", but by "no code diverges"
Sorry, Shu, I'm trying to understand, what are you getting at? E.g., for the <T>value syntax, what harm does it do if TS has a mode that accepts that, and JS never will, but it might support a large other subset of TS/Flow?
23:46
<bakkot>
but there's better syntax for it
23:46
<HE Shi-Jun>
async let have some difficulty in JS (eg. variable capture), but I hope we can explore the possibility.
23:47
<ljharb>
i'm sure we could but that sounds like a different proposal maybe?
23:47
<littledan>
I think the important thing for the TSX transitions was, can people "live in TSX"? and in that sense, it was a complete success
23:47
<littledan>
it needs to be that the syntax that Type Annotations supports is enough to live in; it doesn't need to take over all existing code IMO.
23:47
<HE Shi-Jun>
i'm sure we could but that sounds like a different proposal maybe?
If it's for the same problem, shouldn't it in one proposal?
23:47
<ljharb>
is it the same problem?
23:47
<Michael Ficarra>
I think an all analogue is fine, the others seem to only make sense on unnamed collections
23:47
<rbuckton>
I don't even know what I'd use Promise.raceOwnProperties for.
23:48
<ljharb>
i'd use it for allSettled the same as i'd use it for all. the other two i don't see a use case for tho
23:48
<Justin Ridgewell>
But how do you tell which one won the race?
23:48
<shu>
Sorry, Shu, I'm trying to understand, what are you getting at? E.g., for the <T>value syntax, what harm does it do if TS has a mode that accepts that, and JS never will, but it might support a large other subset of TS/Flow?
i understand that the whole point of this proposal is to bring TS syntax "into the fold". the harm is that if the promise is actually "we will work to converge TS and JS syntax in the future", that sounds like ecosystem divergence to me and i do not have the risk appetite for that
23:48
<HE Shi-Jun>
is it the same problem?
at least it could solve this problem IMO.
23:48
<bakkot>
I think an all analogue is fine, the others seem to only make sense on unnamed collections
allSettled makes sense on named collections
23:48
<bakkot>
the others, no
23:49
<bakkot>
or at least less so
23:49
<ljharb>
i'm not sure it would, but we would certainly explore that kind of thing in stage 1. altho i think solving it with syntax is a much harder sell prior to API existing.
23:49
<Michael Ficarra>
okay yeah I buy that
23:50
<littledan>
i understand that the whole point of this proposal is to bring TS syntax "into the fold". the harm is that if the promise is actually "we will work to converge TS and JS syntax in the future", that sounds like ecosystem divergence to me and i do not have the risk appetite for that
Yeah, this is why the syntax is aligned with TS and Flow for the most part. If we end up doing something like add ::<, it would be in conjunction with the change on the TS side (it's not even in the current grammar yet).
23:50
<shu>
and i am saying, "for the most part" isn't enough for my risk appetite
23:51
<littledan>
and i am saying, "for the most part" isn't enough for my risk appetite
maybe this would be a good thing to dig into in another presentation focused on the syntax?
23:51
<rbuckton>
I've used Promise.all(promises) to avoid a waterfall when queueing up operations where I only need to wait for completion, so I wouldn't say the fact that its list-oriented is just due to "that's what we had at the time"
23:52
<bakkot>
yes, sorry, I was speaking loosely
23:52
<bakkot>
there's really two uses - when you have a homogenous list, where you're probably not destructuring, and where you have a heterogenous list, where you probably are
23:52
<bakkot>
Promise.all is perfect for the first case but awkward for the second
23:53
<rbuckton>
Or when you want to avoid repetition for non-degenerate cases like how the example started out.
23:55
<rbuckton>
const { foo, bar } = Promise.ownProperties({ foo: getFoo(), bar: getBar() }) isn't an improvement over const [foo, bar] = Promise.all([getFoo(), getBar()]) until you reach a level of complexity where that becomes unmanageable (as was illustrated in the example).
23:56
<bakkot>
I think 2 items is probably the limit though
23:56
<bakkot>
like when I have APIs which return 2 values I might return an unnamed pair, but as soon as it's 3 I'm going to name them instead
23:57
<justinfagnani>
the difference with await Promise.all() and function parameters is that you need to lists to use Promise.all vs one args list at the call site for a function (of course a function as a parameter list, but we can't eliminate that)
23:58
<rbuckton>
That said, I'm very much in favor of this as its fairly easy to exhaust that minimum complexity bar for Promise.all(). I'm not terribly enthusiastic about await. syntax, in general. I think an API approach is the right direction for now.
23:58
<justinfagnani>
it's cumbersome to keep these lists in sync, and hard to read when they get long
23:58
<shu>
okay, on the motivation front i am now convinced, and this boils down to kevin's reason: "Promise.all is special, because the ordering of its input list is not semantically meaningful, and so is harder to keep track of mentally. except you have to keep track of it mentally because it must match up to the output list"