I agree!

it’s good to see that Kotlin takes this very seriously and handles it at the language level

in Vert.x we do have an integration with Quasar

and what I like in Kotlin coroutines is that it is maintained by the team doing the language

providing strong guarantees for support

and also no runtime bytecode agent magic

compile time

perfect

Yes. That was the goal (to put in the language). Also, the vision of Kotlin spans beyond JVM and there ain’t any bytecode out there.

And there is no stackless limitation in the concept anymore. There is an implementation artefact in M04 that you can only do tail suspend calls in suspending function, but we’ll lift it in the future. There’s nothing in the concept that prevents us from doing so anymore.

@elizarov Do you have any plans to create some experimental implementation of channels?

I have 100500 plans but only 24 hours in a day. I’d be extremely grateful if somebody from community implements it.

All the building blocks are now in place.

The generator is asynchronous?

That depends on how you define asynchronous. What exact property of generator you are interested in?

// Asynchronous function
Future<String> greeting(String name) async => return “Hello $name”;
final result = await greeting(”Someone”);
greeting().then(print);
// --
// Asynchronous generator
Stream<String> greetingSevenDwarfs() async* {
 const dwarfs = [’one’, ‘two’, '…’];

 for (final dwarf in dwarfs) {
   yield(dwarf)
 }
}
await for (final result in greetingSevenDwarfs()) {
 print(result);
}
greetingSevenDwarfs().listen(print);
// --
// Synchronous generator
Iterator<String> greetingSevenDwarfsSync() sync* {
 const dwarfs = [’one’, ‘two’, '…’];

 for (final dwarf in dwarfs) {
   yield(dwarf)
 }
}
for (final result in greetingSevenDwarfs()) {
 print(result);
}
greetingSevenDwarfs().forEach(print);

I was wondering if Kotlin has an equivalent to the code above.

Both can be implemented in Kotlin in a library.

This document https://github.com/Kotlin/kotlin-coroutines/blob/7c45a175ffd298606225bb4af76fe8acc0b2cd4f/kotlin-coroutines-informal.md gives Kotlin implementation for

generate

and

async

async

is what is called

async*

in the code above. In Kotlin you’d write

fun greeting(name: String): Future<String> = async { … }

generate

is what is called

sync*

in the above code. In Kotlin you’d write

fun greetingSevenDwarfsSync(): Sequence<String> = generate { … }

As a matter of style, I’d actually recommend to add

Async

suffix to

greeting

, that is name it

fun greetingAsync(…): Future<String>

, but drop

Sync

suffix from the other one, that is name it just

fun greetingSevenDwarfs(): Sequence<String>

. Async (future-returning) style of programming is quite error-prone, so it is better to make it explicit.

Wow, thank you for the answer. I must say that I’m not really a java person, yet. I was thinking that

Future

was the equivalent of

Promise

in JavaScript of

Task

in C#

Future

,

Promise

and

Task

are all equivalent.

Note, that

await

in Kotlin is not a keyword either. It is just a library function defined like

suspend <T> fun await(f: Future<T>): T

In Kotlin you are not tied to any particular future/promise/task class. You can write

await

implementation for any and all of them

There are lots of libraries in Java world that define their own future/promise/task class.

In JS world, by the contract, there is a standard

Promise

and, of course, in Kotlin JS you’d write

await

for JS Promise

In JS world there is

Promise

indeed. But for some reason there's IndexedDB API, that is not based on promises

Java future/promise is a mess 🙂

adapt all the things!!!!