<html><body><div style="font-family: arial, helvetica, sans-serif; font-size: 12pt; color: #000000"><div>Hi Daniel,<br></div><div>I've taken a look to your implementation, i think it can be simpler,<br data-mce-bogus="1"></div><div>you can inherits from Continuation, so you can create a subclass of Continuation that implements Iterator with a field to store the yielded value.</div><div><br data-mce-bogus="1"></div><div>RĂ©mi<br data-mce-bogus="1"></div><div><br></div><hr id="zwchr" data-marker="__DIVIDER__"><div data-marker="__HEADERS__"><blockquote style="border-left:2px solid #1010FF;margin-left:5px;padding-left:5px;color:#000;font-weight:normal;font-style:normal;text-decoration:none;font-family:Helvetica,Arial,sans-serif;font-size:12pt;"><b>From: </b>"Alan Bateman" <Alan.Bateman@oracle.com><br><b>To: </b>"Daniel Schmid" <daniel@wwwmaster.at><br><b>Cc: </b>"core-libs-dev" <core-libs-dev@openjdk.org>, "jdk-dev" <jdk-dev@openjdk.org><br><b>Sent: </b>Monday, August 28, 2023 11:12:51 AM<br><b>Subject: </b>Re: yield return based on Coroutines<br></blockquote></div><div data-marker="__QUOTED_TEXT__"><blockquote style="border-left:2px solid #1010FF;margin-left:5px;padding-left:5px;color:#000;font-weight:normal;font-style:normal;text-decoration:none;font-family:Helvetica,Arial,sans-serif;font-size:12pt;"><br>
    This looks fun! It's probably best to bring this to loom-dev. In its
    archives you'll find several discussions about generators as several
    people have been interested in that topic. Even when thread
    confined, the main concern has been that exotic control flow yields
    leads to surprising behavior with many of the existing constructs,
    e.g. in your example think about behavior with finally blocks,
    try-with-resources, locks, ... when the iterator is not fully
    consumed.<br>
    <br>
    -Alan<br>
    <br>
    <div class="moz-cite-prefix">On 28/08/2023 09:43, Daniel Schmid
      wrote:<br>
    </div>
    <blockquote cite="mid:c2f518b5-6ab9-5741-3d2c-a3d7951dc00d@wwwmaster.at">
      
      <p>Hi,</p>
      <p>After seeing the JVM Language Summit talk on Continuations (<a href="https://www.youtube.com/watch?v=6nRS6UiN7X0" class="moz-txt-link-freetext" target="_blank">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 href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence-scope/yield.html" class="moz-txt-link-freetext" target="_blank">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 href="https://github.com/Crain-32" class="moz-txt-link-freetext" target="_blank">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 href="https://github.com/danthe1st/ContinuationYieldReturn" class="moz-txt-link-freetext" target="_blank">https://github.com/danthe1st/ContinuationYieldReturn</a><br data-mce-bogus="1"></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>
    </blockquote>
    <br><br></blockquote></div></div></body></html>