Add validation to the strawman

Author: odersky

tests/run/errorhandling/Result.scala

@@ -28,6 +28,24 @@ object Result:
       case Ok(x) => f(x)
       case err: Err[_] => err
 
+    /** Validate both `r` and `other`; return a pair of successes or a list of failures. */
+    def * [U](other: Result[U, E]): Result[(T, U), List[E]] = (r, other) match
+      case (Ok(x), Ok(y))     => Ok((x, y))
+      case (Ok(_), Err(e))    => Err(e :: Nil)
+      case (Err(e), Ok(_))    => Err(e :: Nil)
+      case (Err(e1), Err(e2)) => Err(e1 :: e2 :: Nil)
+
+    /** Validate both `r` and `other`; return a tuple of successes or a list of failures.
+     *  Unlike with `*`, the right hand side `other` must be a `Result` returning a `Tuple`,
+     *  and the left hand side is added to it. See `Result.empty` for a convenient
+     *  right unit of chains of `*:`s.
+     */
+    def *: [U <: Tuple](other: Result[U, List[E]]): Result[T *: U, List[E]] = (r, other) match
+      case (Ok(x), Ok(ys))     => Ok(x *: ys)
+      case (Ok(_), es: Err[?]) => es
+      case (Err(e), Ok(_))     => Err(e :: Nil)
+      case (Err(e), Err(es))   => Err(e :: es)
+
   /** Simlar to `Try`: Convert exceptions raised by `body` to `Err`s.
    *  In principle, `Try[T]` should be equivalent to `Result[T, Exception]`.
    *  Note that we do not want to catch and reify all Throwables.
@@ -37,9 +55,12 @@ object Result:
    *  (Generally, the focus on `Throwable` in Scala libraries is a mistake.
    *   Use `Exception` instead, as it was meant to in Java.)
    */
-  def apply[T](body: => T): Result[T, Exception] =
+  inline def apply[T](body: => T): Result[T, Exception] =
     try Ok(body)
     catch case ex: Exception => Err(ex)
+
+  /** Right unit for chains of `*:`s. Returns an `Ok` with an `EmotyTuple` value. */
+  def empty: Result[EmptyTuple, Nothing] = Ok(EmptyTuple)
 end Result
 
 /** A prompt for `_.?`. It establishes a boundary to which `_.?` returns */

tests/run/errorhandling/Test.scala

@@ -62,6 +62,14 @@ def resultTest() =
   assertFail(sumRoots(List("1", "-2", "4")), "cannot take sqrt of negative")
   assertFail(sumRoots(List()), "list is empty")
   assertFail(sumRoots(List("1", "3ab")), "NumberFormatException")
+  val xs = sumRoots(List("1", "-2", "4")) *: sumRoots(List()) *: sumRoots(List("1", "3ab")) *: Result.empty
+  xs match
+    case Err(msgs) => assert(msgs.length == 3)
+    case _ => assert(false)
+  val ys = sumRoots(List("1", "2", "4")) *: sumRoots(List("1")) *: sumRoots(List("2")) *: Result.empty
+  ys match
+    case Ok((a, b, c)) => // ok
+    case _ => assert(false)
 
 @main def Test =
   breakTest()

tests/run/errorhandling/kostas.scala

@@ -17,7 +17,7 @@ object PersonCsvParserIgnoreErrors:
   def parse(csv: Seq[String]): Seq[Person] =
     for
       line <- csv
-      columns = line.split(",")x
+      columns = line.split(",")
       parsed <- parseColumns(columns)
     yield
       parsed