Add test from errorhandling strawman

Author: odersky

tests/run/errorhandling/Result.scala

@@ -0,0 +1,45 @@
+package scala.util
+import boundary.Label
+
+abstract class Result[+T, +E]
+case class Ok[+T](value: T)  extends Result[T, Nothing]
+case class Err[+E](value: E) extends Result[Nothing, E]
+
+object Result:
+  extension [T, E](r: Result[T, E])
+
+    /** `_.?` propagates Err to current Label */
+    transparent inline def ? (using Label[Err[E]]): T = r match
+      case r: Ok[_] => r.value
+      case err => break(err.asInstanceOf[Err[E]])
+
+    /** If this is an `Err`, map its value */
+    def mapErr[E1](f: E => E1): Result[T, E1] = r match
+      case err: Err[_] => Err(f(err.value))
+      case ok: Ok[_] => ok
+
+    /** Map Ok values, propagate Errs */
+    def map[U](f: T => U): Result[U, E] = r match
+      case Ok(x) => Ok(f(x))
+      case err: Err[_] => err
+
+    /** Flatmap Ok values, propagate Errs */
+    def flatMap[U](f: T => Result[U, E]): Result[U, E] = r match
+      case Ok(x) => f(x)
+      case err: Err[_] => err
+
+  /** Similar to `Try`: Convert exceptions raised by `body` to `Err`s.
+   */
+  def apply[T](body: => T): Result[T, Exception] =
+    try Ok(body)
+    catch case ex: Exception => Err(ex)
+end Result
+
+/** A prompt for `_.?`. It establishes a boundary to which `_.?` returns */
+object respond:
+  inline def apply[T, E](inline body: Label[Err[E]] ?=> T): Result[T, E] =
+    boundary:
+      val result = body
+      Ok(result)
+
+

tests/run/errorhandling/Test.scala

@@ -0,0 +1,67 @@
+import scala.util.*
+
+/** boundary/break as a replacement for non-local returns */
+def indexOf[T](xs: List[T], elem: T): Int =
+  boundary:
+    for (x, i) <- xs.zipWithIndex do
+      if x == elem then break(i)
+    -1
+
+def breakTest() =
+  println("breakTest")
+  assert(indexOf(List(1, 2, 3), 2) == 1)
+  assert(indexOf(List(1, 2, 3), 0) == -1)
+
+/** traverse becomes trivial to write */
+def traverse[T](xs: List[Option[T]]): Option[List[T]] =
+  optional(xs.map(_.?))
+
+def optTest() =
+  println("optTest")
+  assert(traverse(List(Some(1), Some(2), Some(3))) == Some(List(1, 2, 3)))
+  assert(traverse(List(Some(1), None, Some(3))) == None)
+
+/** A check function returning a Result[Unit, _] */
+inline def check[E](p: Boolean, err: E): Result[Unit, E] =
+  if p then Ok(()) else Err(err)
+
+/** Another variant of a check function that returns directly to the given
+ *  label in case of error.
+ */
+inline def check_![E](p: Boolean, err: E)(using l: boundary.Label[Err[E]]): Unit =
+  if p then () else break(Err(err))
+
+/** Use `Result` to convert exceptions to `Err` values */
+def parseDouble(s: String): Result[Double, Exception] =
+  Result(s.toDouble)
+
+def parseDoubles(ss: List[String]): Result[List[Double], Exception] =
+  respond:
+    ss.map(parseDouble(_).?)
+
+/** Demonstrate combination of `check` and `.?`. */
+def trySqrt(x: Double) = // inferred: Result[Double, String]
+  respond:
+    check(x >= 0, s"cannot take sqrt of negative $x").? // direct jump
+    math.sqrt(x)
+
+/** Instead of `check(...).?` one can also use `check_!(...)`.
+ *  Note use of `mapErr` to convert Exception errors to String errors.
+ */
+def sumRoots(xs: List[String]) = // inferred: Result[Double, String]
+  respond:
+    check_!(xs.nonEmpty, "list is empty")           // direct jump
+    val ys = parseDoubles(xs).mapErr(_.toString).?  // direct jump
+    ys.reduce((x, y) => x + trySqrt(y).?)           // need exception to propagate `Err`
+
+def resultTest() =
+  println("resultTest")
+  assert(sumRoots(List("1", "4", "9")) == Ok(6))
+  assert(sumRoots(List("1", "-2", "4")) == Err(s"cannot take sqrt of negative -2.0"))
+  assert(sumRoots(List()) == Err("list is empty"))
+  assert(sumRoots(List("1", "3ab")) == Err("java.lang.NumberFormatException: For input string: \"3ab\""))
+
+@main def Test =
+  breakTest()
+  optTest()
+  resultTest()

tests/run/errorhandling/optional.scala

@@ -0,0 +1,20 @@
+package scala.util
+import boundary.Label
+
+/** A mockup of scala.Option */
+abstract class Option[+T]
+case class Some[+T](x: T) extends Option[T]
+case object None extends Option[Nothing]
+
+object Option:
+  /** This extension should be added to the companion object of scala.Option */
+  extension [T](r: Option[T])
+    inline def ? (using label: Label[None.type]): T = r match
+      case Some(x) => x
+      case None => break(None)
+
+/** A prompt for `Option`, which establishes a boundary which `_.?` on `Option` can return */
+object optional:
+  inline def apply[T](inline body: Label[None.type] ?=> T): Option[T] =
+    boundary(Some(body))
+