Use ExecutionContext instead of Scheduler

Author: odersky

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

@@ -1,6 +1,7 @@
 package concurrent
 import java.util.concurrent.atomic.AtomicBoolean
 import scala.collection.mutable
+import scala.concurrent.ExecutionContext
 
 /** A context that allows to suspend waiting for asynchronous data sources
  */
@@ -18,14 +19,15 @@ trait Async:
 object Async:
 
   /** The underlying configuration of an async block */
-  case class Config(scheduler: Scheduler, group: Cancellable.Group)
+  case class Config(scheduler: ExecutionContext, group: Cancellable.Group)
 
   trait LowPrioConfig:
 
     /** A toplevel async group with given scheduler and a synthetic root that
      *  ignores cancellation requests
      */
-    given fromScheduler(using s: Scheduler): Config = Config(s, Cancellable.Unlinked)
+    given fromExecutionContext(using scheduler: ExecutionContext): Config =
+      Config(scheduler, Cancellable.Unlinked)
 
   end LowPrioConfig
 
@@ -57,7 +59,7 @@ object Async:
   /** Execute asynchronous computation `body` on currently running thread.
    *  The thread will suspend when the computation waits.
    */
-  def blocking[T](body: Async ?=> T)(using Scheduler): T =
+  def blocking[T](body: Async ?=> T)(using ExecutionContext): T =
     body(using Blocking())
 
   /** The currently executing Async context */

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

@@ -2,9 +2,10 @@
 
 import concurrent.*
 import fiberRuntime.boundary.setName
+import scala.concurrent.ExecutionContext
 
 @main def Test =
-  given Scheduler = Scheduler
+  given ExecutionContext = ExecutionContext.global
   val x = Future:
     setName("x")
     val a = Future{ setName("xa"); 22 }

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

@@ -2,7 +2,7 @@ package concurrent
 import scala.collection.mutable, mutable.ListBuffer
 import fiberRuntime.boundary, boundary.Label
 import fiberRuntime.suspend
-import java.util.concurrent.CancellationException
+import scala.concurrent.ExecutionContext
 import Async.{Listener, await}
 
 /** An unbounded asynchronous channel. Senders do not wait for matching
@@ -97,7 +97,7 @@ object SyncChannel:
 
 end SyncChannel
 
-def TestChannel(using Scheduler) =
+def TestChannel(using ExecutionContext) =
   val c = SyncChannel[Option[Int]]()
   Future:
     for i <- 0 to 100 do

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

@@ -7,6 +7,7 @@ import scala.compiletime.uninitialized
 import scala.util.{Try, Success, Failure}
 import scala.annotation.unchecked.uncheckedVariance
 import java.util.concurrent.CancellationException
+import scala.concurrent.ExecutionContext
 
 /** A cancellable future that can suspend waiting for other asynchronous sources
  */
@@ -103,7 +104,7 @@ object Future:
               var result: Option[T] = None // Not needed if we have full continuations
               suspend[T, Unit]: k =>
                 src.onComplete: x =>
-                  config.scheduler.schedule: () =>
+                  config.scheduler.execute: () =>
                     result = Some(x)
                     k.resume()
                   true // signals to `src` that result `x` was consumed
@@ -124,7 +125,7 @@ object Future:
         body(using FutureAsync())
     end async
 
-    ac.scheduler.schedule: () =>
+    ac.scheduler.execute: () =>
       async:
         link()
         Async.group:
@@ -198,7 +199,7 @@ class Task[+T](val body: Async ?=> T):
 
 end Task
 
-def add(x: Future[Int], xs: List[Future[Int]])(using Scheduler): Future[Int] =
+def add(x: Future[Int], xs: List[Future[Int]])(using ExecutionContext): Future[Int] =
   val b = x.zip:
     Future:
       xs.headOption.toString
@@ -217,6 +218,6 @@ def add(x: Future[Int], xs: List[Future[Int]])(using Scheduler): Future[Int] =
 
 end add
 
-def Main(x: Future[Int], xs: List[Future[Int]])(using Scheduler): Int =
+def Main(x: Future[Int], xs: List[Future[Int]])(using ExecutionContext): Int =
   Async.blocking(add(x, xs).value)
 

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

@@ -3,7 +3,9 @@ package simpleFutures
 import scala.collection.mutable.ListBuffer
 import scala.util.boundary, boundary.Label
 import runtime.suspend
-import concurrent.Scheduler
+
+object Scheduler:
+  def schedule(task: Runnable): Unit = ???
 
 trait Async:
   def await[T](f: Future[T]): T