I’ve recently read the in v8 blog. It's about two upcoming methods in Promise API: and . And I feel frustrated. The design of these methods looks to me inconsistent with current Promise API. Let me share my opinion below. Promise combinators article Promise.allSettled() Promise.any() Promise.allSettled According to article: Promise.allSettled gives you a signal when all the input promises are settled, which means they're either fulfilled or rejected. The use-case is to send several API calls and wait for all finished: promises = [ fetch( ), fetch( ), fetch( ), ]; .allSettled(promises); removeLoadingIndicator(); const '/api-call-1' '/api-call-2' '/api-call-3' await Promise For sure, this is useful. But this task can be easily solved with and . The change is minimal: .map() Promise.all() promises = [ fetch( ), fetch( ), fetch( ), ].map( p.catch( e)); .all(promises); removeLoadingIndicator(); const '/api-call-1' '/api-call-2' '/api-call-3' => p => e // <-- the only change await Promise Is it worth implementing a new core method that can be solved in a few lines of code? As for me this is a library-land feature, not the core API method. But more important is that brings extra level of abstraction. Unlike it fulfills with array of wrapping objects instead of pure promise values. As a developer I don’t like it. I expect that methods with similar names behave similar ways. But they don’t. Promise.allSettled Promise.all {status, reason} .all()/.allSettled() Moreover, the code with encourages late errors handling. Errors supposed to be filtered out from the final result instead of traditional block. This, in turn, has the following downsides: Promise.allSettled catch errors are not handled immediately, at the moment when they occur. In case of several related errors you can't know which was the original one. And log will contain incorrect timestamps. errors are not handled if at least one promise is pending forever. Using current you avoid such things. Promise.all Promise.any Promise.any gives you a signal as soon as one of the promises fulfills. In other words is that ignores rejections. Promise.any Promise.race The use-case is to check several endpoints and take data from the first successful one: promises = [ fetch( ).then( ), fetch( ).then( ), fetch( ).then( ), ]; { first = .any(promises); } (error) { .log(error); } const '/endpoint-a' => () 'a' '/endpoint-b' => () 'b' '/endpoint-c' => () 'c' try const await Promise catch // All of the promises were rejected. console I agree sometimes it may be useful. But how often? In how many projects did you use the pattern “ ? Feel free to share in comments. But from my vision — not very often. Couldn’t it be more useful for community to get native implementation of or ? make several parallel requests to identical endpoints for the same data” bluebird’s Promise.each() Promise.delay() Moreover, introduces a new type of error — . Such error contains links to other errors if all promises are rejected. One more error handling approach! It differs from where errors are extracted from success result. It also differs from which reject with just an instance. How will JavaScript look like if every new Promise API method will introduce new way of error handling? Although the I’m concerned about the direction. Promise.any AggregateError Promise.allSettled Promise.all/Promise.race Error proposal is on a very early stage, Based on current Promise API the implementation of is a bit tricky but actually : Promise.any two lines of code reverse = ( .resolve(p).then(reject, resolve)); .any = reverse( .all(arr.map(reverse))); const => p new Promise ( ) => resolve, reject Promise Promise => arr Promise Maybe keep it in library-land? Inconsistency Why and are so pretty? Promise.all Promise.race Because they behave very consistent and similar to usual promises: fulfill with just a value and reject with just an error. No wrapped values, no accumulated errors, no extra complexity. Why and are so weird to me? Promise.allSettled Promise.any fulfills with array of objects with status and reason wrapping underlying promise values. And rejects… never. Promise.allSettled fulfills with a single value but ignores intermediate rejections. Only if all promises are rejected it rejects with accumulated reason wrapping all underlying reasons. Promise.any These new approaches are really difficult to put in my head. As they are quite different from the current Promise API. I suppose a popular job interview question in 2020: What’s the difference of these four methods? Promise.all() Promise.allSettled() Promise.race() Promise.any() Although it’s cool question I don’t think core API should encourage such complexity. Naming I’m also disappointed with naming. Four methods with slightly different behavior should have pretty clear names. Otherwise I have to re-check every time I meet them in code. From the of : MDN proposal Promise.any It clearly describes what it does Let me to disagree. For me the name of is confusing: Promise.any Will it fulfill if of promises fulfills? . any Yes Will it reject if of promises rejects? . any No Will it settle if of promises settle? . any It depends How it differs from ? .. Promise.race Hmm I think, the name of each method should explicitly define the condition when the method fulfills. I would suggest the following naming convention: .all -> .allFulfilled .allSettled -> .allSettled .race -> .oneSettled .any -> .oneFulfilled Promise Promise Promise Promise Promise Promise Promise Promise It reflects four possible combinations of promise states. It explains why these methods are referenced as in proposal. combinators Of course, such rename is not possible as and already landed and used in many applications. But for new methods having some naming strategy would be very helpful. Promise.all Promise.race I've in proposal repository on GitHub, you are welcome to share you thoughts. opened issue Promise.any Swallowed rejections In general I'm not inspired with the concept of non-thrown “swallowed” rejections. In fact, new Promise API provides a way to silently ignore errors in the code: never rejects. Promise.allSettled rejects only if all promises rejected. Promise.any Currently no other core JavaScript API does that. The only way to ignore an error — manually wrap it into with empty body. And write a comment why do you ignore error here, otherwise . try..catch/.catch() eslint will warn you I think . It is always a developer decision whether to handle error or not. It should be explicit for other developers reading the code. Just imagine how many hours of debugging will be spent due to inaccurate usage of swallowed rejections! Especially when dealing with third-party code— when something does not work and no errors thrown. the core API should expose all errors Conclusion I use promises every working day. As well as many other developers do. I love JavaScript for its async nature. Having clear and intuitive API allows me to solve tasks faster and be more productive. That’s why I think Promise API should be treated and changed very carefully. Thanks for reading and welcome to comments.
