<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body>
<p>Hi,</p>
<p>After seeing the JVM Language Summit talk on Continuations (<a
moz-do-not-send="true"
href="https://www.youtube.com/watch?v=6nRS6UiN7X0"
class="moz-txt-link-freetext">https://www.youtube.com/watch?v=6nRS6UiN7X0</a>),
I thought about it being possible to implement something like
"yield return" in languages like C# (or "yield" in Python) based
on Continuations.<br>
Kotlin has implemented a similar feature as well: <a
moz-do-not-send="true"
href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence-scope/yield.html"
class="moz-txt-link-freetext">https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence-scope/yield.html</a><br>
Now that Continuations are in the JDK, I feel like it can be used
as a good primitive and now is a good time to start about thinking
about adding something like this as a Java feature or the
libraries.</p>
<p>After my experiments and some discussion with another developer
named Peter Eastham (<a moz-do-not-send="true"
href="https://github.com/Crain-32" class="moz-txt-link-freetext">https://github.com/Crain-32</a>),
I was able to come up with an implementation/proof-of-concept
allowing something like the following:</p>
<pre>public static void main(String[] args) {
System.out.println("main thread: " + Thread.currentThread());
for (String s : Yielder.create(YieldReturnTest::someMethod)) {
System.out.println("Text: " + s);
}
}
private static void someMethod(Yielder<String> y) {
y.yield("Hello - " + Thread.currentThread());
System.out.println("between yields");
y.yield("World - " + Thread.currentThread());
for (String s : Yielder.create(YieldReturnTest::otherMethod)) {
y.yield("nested: " + s);
}
y.yield("bye - " + Thread.currentThread());
}
private static void otherMethod(Yielder<String> y) {
y.yield("it can");
y.yield("also be");
y.yield("nested");
}</pre>
<p>output:</p>
<pre>main thread: Thread[#1,main,5,main]
Text: Hello - Thread[#1,main,5,main]
between yields
Text: World - Thread[#1,main,5,main]
Text: nested: it can
Text: nested: also be
Text: nested: nested
Text: bye - Thread[#1,main,5,main]</pre>
<p>In this example, the method reference passed to the
Yielder.create method would be run in a Continuation while y.yield
would yield the Continuation and make the value available to the
iterator (next() calls Continuation#run).<br>
</p>
<p>You can find a simple proof-of-concept of that here: <a
moz-do-not-send="true"
href="https://github.com/danthe1st/ContinuationYieldReturn"
class="moz-txt-link-freetext">https://github.com/danthe1st/ContinuationYieldReturn</a></p>
<p>Would it be possible to add something like this to the JDK
libraries?<br>
I feel like it might be a useful addition to the JDK libraries as
it simplifies creating sequences a lot.</p>
<p>Originally, I thought about whether it might be a good idea to
add syntax for this but after building that proof-of-concept, it
looks like it would be sufficient to add this to the libraries and
using methods like this seems pretty natural.<br>
One thing I am concerned with this approach (opposed to an
approach that involves changing syntax) is that it would be
possible that the method suddenly runs in a different thread if
the hasNext()/next()-calls of the Iterator chang the thread they
are used in at some point. While Continuations allow this
behaviour, it might seem a weird to developers who don't know how
Continuations work.<br>
But aside from that issue with iterations switching threads, this
approach seems pretty natural to me.<br>
</p>
<p>Yours,<br>
Daniel<br>
</p>
</body>
</html>