Make Async.Group a field in Async instead of inheriting from it

Author: odersky

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

@@ -4,38 +4,40 @@ import scala.collection.mutable
 
 /** A context that allows to suspend waiting for asynchronous data sources
  */
-trait Async extends Async.Config:
+trait Async:
 
   /** Wait for completion of async source `src` and return the result */
   def await[T](src: Async.Source[T]): T
 
-  /** An Async of the same kind as this one, with a given cancellation group */
-  def withGroup(group: Cancellable.Group): Async
+  /** The configuration of this Async */
+  def config: Async.Config
+
+  /** An Async of the same kind as this one, with a new configuration as given */
+  def withConfig(config: Async.Config): Async
 
 object Async:
 
   /** The underlying configuration of an async block */
-  trait Config:
-
-    /** The group of cancellableup to which nested futures belong */
-    def group: Cancellable.Group
+  case class Config(scheduler: Scheduler, group: Cancellable.Group)
 
-    /** The scheduler for runnables defined in this async computation */
-    def scheduler: Scheduler
-
-  object Config:
+  trait LowPrioConfig:
 
     /** A toplevel async group with given scheduler and a synthetic root that
      *  ignores cancellation requests
      */
-    given fromScheduler(using s: Scheduler): Config with
-      def group = Cancellable.Unlinked
-      def scheduler = s
+    given fromScheduler(using s: Scheduler): Config = Config(s, Cancellable.Unlinked)
+
+  end LowPrioConfig
+
+  object Config extends LowPrioConfig:
+
+    /** The async configuration stored in the given async capabaility */
+    given fromAsync(using async: Async): Config = async.config
 
   end Config
 
   /** An implementation of Async that blocks the running thread when waiting */
-  private class Blocking(val scheduler: Scheduler, val group: Cancellable.Group) extends Async:
+  private class Blocking(using val config: Config) extends Async:
 
     def await[T](src: Source[T]): T =
       src.poll().getOrElse:
@@ -49,15 +51,14 @@ object Async:
           while result.isEmpty do wait()
           result.get
 
-    def withGroup(group: Cancellable.Group) = Blocking(scheduler, group)
+    def withConfig(config: Config) = Blocking(using config)
   end Blocking
 
-
   /** Execute asynchronous computation `body` on currently running thread.
    *  The thread will suspend when the computation waits.
    */
-  def blocking[T](body: Async ?=> T, scheduler: Scheduler = Scheduler): T =
-    body(using Blocking(scheduler, Cancellable.Unlinked))
+  def blocking[T](body: Async ?=> T)(using Scheduler): T =
+    body(using Blocking())
 
   /** The currently executing Async context */
   inline def current(using async: Async): Async = async
@@ -67,7 +68,7 @@ object Async:
 
   def group[T](body: Async ?=> T)(using async: Async): T =
     val newGroup = Cancellable.Group().link()
-    body(using async.withGroup(newGroup))
+    body(using async.withConfig(async.config.copy(group = newGroup)))
 
   /** A function `T => Boolean` whose lineage is recorded by its implementing
    *  classes. The Listener function accepts values of type `T` and returns

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

@@ -21,8 +21,8 @@ trait Cancellable:
   /** Link this cancellable to the cancellable group of the
    *  current async context.
    */
-  def link()(using ac: Async): this.type =
-    link(ac.group)
+  def link()(using async: Async): this.type =
+    link(async.config.group)
 
   /** Unlink this cancellable from its group. */
   def unlink(): this.type =

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

@@ -88,7 +88,7 @@ object Future:
 
     /** a handler for Async */
     private def async(body: Async ?=> Unit): Unit =
-      class FutureAsync(val scheduler: Scheduler, val group: Cancellable.Group) extends Async:
+      class FutureAsync(using val config: Async.Config) extends Async:
 
         def checkCancellation() =
           if cancelRequest then throw CancellationException()
@@ -103,7 +103,7 @@ object Future:
               var result: Option[T] = None // Not needed if we have full continuations
               suspend[T, Unit]: k =>
                 src.onComplete: x =>
-                  scheduler.schedule: () =>
+                  config.scheduler.schedule: () =>
                     result = Some(x)
                     k.resume()
                   true // signals to `src` that result `x` was consumed
@@ -118,10 +118,10 @@ object Future:
               */
             finally checkCancellation()
 
-        def withGroup(group: Cancellable.Group) = FutureAsync(scheduler, group)
+        def withConfig(config: Async.Config) = FutureAsync(using config)
 
       boundary [Unit]:
-        body(using FutureAsync(ac.scheduler, ac.group))
+        body(using FutureAsync())
     end async
 
     ac.scheduler.schedule: () =>