Polishings

Author: odersky

tests/run/suspend-strawman-2/Async.scala

@@ -53,14 +53,22 @@ object Async:
       checkCancellation()
       src.poll().getOrElse:
         try
-          var result: Option[T] = None
+          var result: Option[T] = None // Not needed if we have full continuations
           suspend[T, Unit]: k =>
             src.onComplete: x =>
               scheduler.schedule: () =>
                 result = Some(x)
                 k.resume()
               true // signals to `src` that result `x` was consumed
           result.get
+          /* With full continuations, the try block can be written more simply as follows:
+
+            suspend[T, Unit]: k =>
+              src.onComplete: x =>
+                scheduler.schedule: () =>
+                  k.resume(x)
+              true
+          */
         finally checkCancellation()
 
   end Impl
@@ -109,11 +117,6 @@ object Async:
    */
   abstract case class ForwardingListener[T](src: Source[?], continue: Listener[?]) extends Listener[T]
 
-  /** A listener for values that are processed directly in an async block.
-   *  Closures of type `T => Boolean` can be SAM converted to this type.
-   */
-  abstract case class FinalListener[T](apply: T => Boolean) extends Listener[T]
-
   /** An asynchronous data source. Sources can be persistent or ephemeral.
    *  A persistent source will always pass same data to calls of `poll and `onComplete`.
    *  An ephememral source can pass new data in every call.
@@ -158,7 +161,7 @@ object Async:
     /** Add `k` to the listener set of this source */
     protected def addListener(k: Listener[T]): Unit
 
-    def onComplete(k: Listener[T]): Unit = synchronized:
+    def onComplete(k: Listener[T]): Unit =
       if !poll(k) then addListener(k)
 
   end OriginalSource
@@ -232,8 +235,8 @@ object Async:
   /** If left (respectively, right) source succeeds with `x`, pass `Left(x)`,
    *  (respectively, Right(x)) on to the continuation.
    */
-  def either[T, U](src1: Source[T], src2: Source[U]): Source[Either[T, U]] =
-    race[Either[T, U]](src1.map(Left(_)), src2.map(Right(_)))
+  def either[T1, T2](src1: Source[T1], src2: Source[T2]): Source[Either[T1, T2]] =
+    race(src1.map(Left(_)), src2.map(Right(_)))
 
 end Async
 

tests/run/suspend-strawman-2/Test.scala

@@ -16,6 +16,11 @@ import fiberRuntime.boundary.setName
     val a = Future{ setName("ya"); 22 }
     val b = Future{ setName("yb"); 11 }
     a.zip(b).value
+  val z = Future:
+    val a = Future{ setName("za"); 22 }
+    val b = Future{ setName("zb"); true }
+    a.alt(b).value
+  val _: Future[Int | Boolean] = z
   println("test async:")
   Async.blocking:
     println(x.value)
@@ -24,3 +29,4 @@ import fiberRuntime.boundary.setName
   //println(TestChoices)
 
 
+

tests/run/suspend-strawman-2/futures.scala

@@ -123,13 +123,13 @@ object Future:
     ac.root.addChild(f)
     f
 
-  extension [T1](f1: Future[T1])
+  extension [T](f1: Future[T])
 
     /** Parallel composition of two futures.
      *  If both futures succeed, succeed with their values in a pair. Otherwise,
      *  fail with the failure that was returned first and cancel the other.
      */
-    def zip[T2](f2: Future[T2])(using Async.Config): Future[(T1, T2)] = Future:
+    def zip[U](f2: Future[U])(using Async.Config): Future[(T, U)] = Future:
       Async.await(Async.either(f1, f2)) match
         case Left(Success(x1))  => (x1, f2.value)
         case Right(Success(x2)) => (f1.value, x2)
@@ -140,7 +140,7 @@ object Future:
      *  If either task succeeds, succeed with the success that was returned first
      *  and cancel the other. Otherwise, fail with the failure that was returned last.
      */
-    def alt[T2 >: T1](f2: Future[T2], name: String = "alt")(using Async.Config): Future[T2] = Future:
+    def alt(f2: Future[T], name: String = "alt")(using Async.Config): Future[T] = Future:
       boundary.setName(name)
       Async.await(Async.either(f1, f2)) match
         case Left(Success(x1))    => f2.cancel(); x1