Strawman: Suspensions for algebraic effects

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3080,8 +3080,8 @@ object Parsers {
  /* -------- PARAMETERS ------------------------------------------- */
 
     /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
-     *  DefParamClause        ::= DefTypeParamClause 
-     *                          | DefTermParamClause 
+     *  DefParamClause        ::= DefTypeParamClause
+     *                          | DefTermParamClause
      *                          | UsingParamClause
      */
     def typeOrTermParamClauses(
@@ -3179,7 +3179,7 @@ object Parsers {
      *  UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
-     * 
+     *
      *  TypelessClause    ::= DefTermParamClause
      *                      | UsingParamClause
      *
@@ -3557,13 +3557,13 @@ object Parsers {
       }
     }
 
-    
+
 
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
      *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
      *  DefSig  ::=  id [DefTypeParamClause] DefTermParamClauses
-     * 
+     *
      * if clauseInterleaving is enabled:
      *  DefSig  ::=  id [DefParamClauses] [DefImplicitClause]
      */
@@ -3602,8 +3602,8 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val paramss = 
-          if in.featureEnabled(Feature.clauseInterleaving) then 
+        val paramss =
+          if in.featureEnabled(Feature.clauseInterleaving) then
             // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
             typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
           else
@@ -3613,7 +3613,7 @@ object Parsers {
             joinParams(tparams, vparamss)
 
         var tpt = fromWithinReturnType { typedOpt() }
-        
+
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if in.token == EQUALS then

library/src/scala/util/boundary.scala

@@ -33,6 +33,11 @@ object boundary:
     /*message*/ null, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false)
 
   /** Labels are targets indicating which boundary will be exited by a `break`.
+   *  A Label is generated and passed to code wrapped in a `boundary` call. Example
+   *
+   *    boundary[Unit]:
+   *      ...
+   *      summon[Label[Unit]] // will link to the label generated by `boundary`
    */
   final class Label[-T]
 

tests/pos/suspend-strawman-1/choices.scala

@@ -0,0 +1,84 @@
+import collection.mutable.ListBuffer
+import scala.util.boundary, boundary.{Label, break}
+import runtime.*
+
+/** A single method iterator */
+abstract class Choices[+T]:
+  def next: Option[T]
+
+object Choices:
+  def apply[T](elems: T*): Choices[T] =
+    apply(elems.iterator)
+
+  def apply[T](it: Iterator[T]) = new Choices[T]:
+    def next = if it.hasNext then Some(it.next) else None
+end Choices
+
+/** A Label representikng a boundary to which can be returned
+ *   - None,  indicating an mepty choice
+ *   - a suspension with Option[T] result, which will be
+ *     iterated over element by element in the boundary's result.
+ */
+type CanChoose[T] = Label[None.type | Suspension[Option[T]]]
+
+/** A variable representing Choices */
+class Ref[T](choices: => Choices[T]):
+
+  /** Try all values of this variable. For each value, run the continuation.
+   *  If it yields a Some result take that as the next value of the enclosing
+   *  boundary. If it yields a Non, skip the element.
+   */
+  def each[R](using CanChoose[R]): T =
+    val cs = choices
+    suspend()
+    cs.next.getOrElse(break(None))
+
+end Ref
+
+/** A prompt to iterate a compputation `body` over all choices of
+ *  variables which it references.
+ *  @return all results in a new `Choices` iterator,
+ */
+def choices[T](body: CanChoose[T] ?=> T): Choices[T] = new Choices:
+  var stack: List[Suspension[Option[T]]] = Nil
+
+  def next: Option[T] =
+    boundary(Some(body)) match
+      case s: Some[T] => s
+      case None =>
+        if stack.isEmpty then
+          // no (more) variable choices encountered
+          None
+        else
+          // last variable's choices exhausted; use next value of previous variable
+          stack = stack.tail
+          stack.head.resume()
+      case susp: Suspension[Option[T]] =>
+        // A new Choices variable was encountered
+        stack = susp :: stack
+        stack.head.resume()
+
+@main def test: Choices[Int] =
+  val x = Ref(Choices(1, -2, -3))
+  val y = Ref(Choices("ab", "cde"))
+  choices:
+    val xx = x.each
+    xx + (
+      if xx > 0 then y.each.length * x.each
+      else y.each.length
+    )
+    /* Gives the results of the following computations:
+        1 + 2 * 1
+        1 + 2 * -2
+        1 + 2 * -3
+        1 + 3 * 1
+        1 + 3 * -2
+        1 + 3 * -3
+        -2 + 2
+        -2 + 3
+        -3 + 2
+        -3 + 3
+    */
+
+
+

tests/pos/suspend-strawman-1/futures.scala

@@ -0,0 +1,44 @@
+import collection.mutable.ListBuffer
+import scala.util.boundary, boundary.{Label, break}
+import runtime.*
+
+/** A suspension and a value indicating the Future for which the suspension is waiting */
+type Waiting = (Suspension[Unit], Future[?])
+
+/** The capability to suspend while waiting for some other future */
+type CanWait = Label[Waiting]
+
+class Future[+T] private ():
+  private var result: Option[T] = None
+  private var waiting: ListBuffer[Runnable] = ListBuffer()
+
+  /** Return future's result, while waiting until it is completed if necessary.
+   */
+  def await(using CanWait): T = result match
+    case Some(x) => x
+    case None =>
+      suspend((s: Suspension[Unit]) => (s, this))
+      await
+
+object Future:
+
+  private def complete[T](f: Future[T], value: T): Unit =
+    f.result = Some(value)
+    f.waiting.foreach(Scheduler.schedule)
+    f.waiting = ListBuffer()
+
+  /** Create future that eventually returns the result of `op` */
+  def apply[T](body: CanWait ?=> T): Future[T] =
+    val f = new Future[T]
+    Scheduler.schedule: () =>
+      boundary[Unit | Waiting]:
+        complete(f, body)
+      match
+        case (suspension, blocking) =>
+          blocking.waiting += (() => suspension.resume())
+        case () =>
+    f
+
+def Test(x: Future[Int], xs: List[Future[Int]]) =
+  Future:
+    x.await + xs.map(_.await).sum

tests/pos/suspend-strawman-1/runtime.scala

@@ -0,0 +1,21 @@
+import scala.util.boundary, boundary.Label
+object runtime:
+
+  /** A hypthetical task scheduler */
+  object Scheduler:
+    def schedule(task: Runnable): Unit = ???
+
+  /** Contains a delimited contination, which can be invoked with `resume` */
+  class Suspension[+R]:
+    def resume(): R = ???
+
+  /** Returns `fn(s)` where `s` is the current suspension to the boundary associated
+   *  with the given label.
+   */
+  def suspend[R, T](fn: Suspension[R] => T)(using Label[T]): T = ???
+
+  /** Returns the current suspension to the boundary associated
+   *  with the given label.
+   */
+  def suspend[R]()(using Label[Suspension[R]]): Unit =
+    suspend[R, Suspension[R]](identity)

tests/run/suspend-strawman-2.check

@@ -0,0 +1,3 @@
+test async:
+33
+(22,11)