proposal-async-iteration

What you've written isn't invalid, it just does something different. Async iterators effectively yield awaitable promises instead of values. Iterators, normally, are synchronous. Generators immediately yield control to whatever is consuming from it. An async iterator yields things that will eventually yield control. The best example I can think of is disk IO. In Python you can iterate over a file handle, but in JS you can't (without blocking). Async iterators would enable this: each yielded promise would resolve with the next line of the file. Edit: the spec is pretty interesting: https://github.com/tc39/proposal-async-iteration/blob/master...

All proposals that might be made stage 4 (in other words made a part of the JavaScript standard) after this meeting: RegExp lookbehind assertions [1] RegExp Unicode property escapes [2] Async Iteration [3] Promise.prototype.finally [4] Function.prototype.toString [5] Rest/Spread properties [6] [1]: https://github.com/tc39/proposal-regexp-lookbehind [2]: https://github.com/tc39/proposal-regexp-unicode-property-esc... [3]: https://github.com/tc39/proposal-async-iteration [4]: https://github.com/tc39/proposal-promise-finally/ [5]: https://github.com/tc39/Function-prototype-toString-revision [6]: https://github.com/tc39/proposal-object-rest-spread

I'm still awaiting async iterables [1] in Node.js. It's not part of ECMAScript yet, but I'm still excited for it. Chrome 63 and v8 6.3 enables async iterables, but this Node.js version (v9.4) uses v8 6.2 so no async iterables yet. Does anyone know whether a version of Node sticks with the same version of v8 throughout? So, is there any chance that a node version 9 will have v8 greater than 6.2? [1]: https://github.com/tc39/proposal-async-iteration

The callback style pseudo code they posted as an example is not a good example of callback style JavaScript code. The first code posted is showing callback style with a nested loop over a directory listing to perform an image resize using graphics magick. Aside from the fact the author isn't actually calling any callbacks to indicate a complete event ( and won't be able to unless they have an async iterator ), there is a concurrency problem with usage of gm. You really actually want to a run something like an async eachLimit in order to set the amount of open GM instances running concurrently or run the risk of running out of memory / cpu. The second example using async/await doesn't mention anything about using async iterators either. see: http://caolan.github.io/async/docs.html#eachLimit https://github.com/tc39/proposal-async-iteration

I'm really hoping async iterators [1] will make it to stage 4, but from the github I can't really tell what's holding it back as it has several browsers with implementation (I know that's not the only requirement for stage 4, but it's one of them.) I also noticed it's not on the agenda for the November meeting [2]. I understand there are a lot of features being worked on concurrently so it may not be finished by ES2018, but is there any chance someone could give me an update on what's happening with it. I just think this feature is amazing! And also thanks TC39 for all the great features coming to ECMAScript! [1]: https://github.com/tc39/proposal-async-iteration [2]: https://github.com/tc39/agendas/blob/master/2017/11.md

Async iterables seem to be more like a unifying feature to me. For example the TC39 docs on async iterable say this: > Furthermore, we introduce a new symbol > used for obtaining an async iterator > from a given object, Symbol.asyncIterator. > This allows arbitrary objects to advertise > that they are async iterables, similar to > how Symbol.iterator allows you to advertise > being a normal, synchronous iterable. > An example of a class that might use this > is a readable stream. [1] So, the readable stream may end up implementing this api. I went to see if the same thing might go for the observable api. I found that they may have the ability of coercing async iterables with Observable.from()[2] or they could have the ability for asyncIterators to be used as observables through other methods [3]. Observables do implement their own

I am a JS programmer and I have mixed feelings about this. I am not entirely sold on the stuff that comes after async/await. In particular, I am curious to know what folks here think about cancelable promises [1] and the try...else block that might be introduced. Or about async iterators [2], where you can `yield await` stuff. [1] https://github.com/tc39/proposal-cancelable-promises [2] https://github.com/tc39/proposal-async-iteration