Piggyback unrelated tests

Author: odersky

tests/pos/boundary-variations.scala

@@ -0,0 +1,52 @@
+import util.boundary
+import boundary.{break, Label}
+
+def run(f: Int => String, x: Int): String =
+  boundary:
+    def recur(x: Int): String =
+      if x < 0 then break("negative")
+      else if x == 0 then ""
+      else f(x) ++ " " ++ recur(x - 1)
+    recur(x)
+
+def runDyn(f: Int => Label[String] ?=> String, x: Int): String =
+  boundary:
+    def recur(x: Int): String =
+      if x < 0 then break("negative")
+      else if x == 0 then ""
+      else f(x) ++ " " ++ recur(x - 1)
+    recur(x)
+
+def toStr(x: Int)(using lbl: Label[String]): String = x.toString
+
+def middleDyn(x: Int)(using lbl: Label[String]) =
+  if x == 1 then break("middleman attack")(using lbl)
+  x.toString
+
+case class Break(s: String) extends Exception
+
+def runExc(f: Int => String, x: Int): String =
+  try
+    def recur(x: Int): String =
+      if x < 0 then throw Break("negative")
+      else if x == 0 then ""
+      else f(x) ++ " " ++ recur(x - 1)
+    recur(x)
+  catch case Break(s) => s
+
+def middleExc(x: Int) =
+  if x == 1 then throw Break("middleman attack")
+  x.toString
+
+@main def Test =
+  println(run(_.toString, 2))
+  println(run(_.toString, -2))
+
+  println(runDyn(toStr, 2))
+  println(runDyn(toStr, -2))
+  println(runDyn(middleDyn, 2))
+
+  println(runExc(_.toString, 2))
+  println(runExc(_.toString, -2))
+  println(runExc(middleExc, 2))
+

tests/run/namedtuples-buildcolumn.check

@@ -0,0 +1,2 @@
+(kind = Dog, age = 7, weight = 6.5)
+(kind = Dog, age = 7, weight = 6.5, growth = 0.9285714285714286)

tests/run/namedtuples-buildcolumn.scala

@@ -0,0 +1,30 @@
+import NamedTuple.*
+import compiletime.{constValue, erasedValue}
+
+// The generic buildColumn function
+transparent inline def buildColumn[N <: Tuple, V <: Tuple, T](
+  r: NamedTuple[N, V], name: String, f: NamedTuple[N, V] => T)
+  (using Tuple.Disjoint[N, Tuple1[name.type]] =:= true)
+    : Concat[NamedTuple[N, V], NamedTuple[Tuple1[name.type], Tuple1[T]]]
+    = r ++ Tuple1(f(r)).withNames[Tuple1[name.type]]
+
+extension [N <: Tuple, V <: Tuple](r: NamedTuple[N, V])
+  inline def mkString: String =
+    r.toSeqMap
+      .map((n, v) => s"$n = $v")
+      .mkString("(", ", ", ")")
+
+// Concrete Pet example
+type Pet = (kind: String, age: Int, weight: Double)
+
+val pet = (kind = "Dog", age = 7, weight = 6.5)
+
+@main def Test =
+  val pet2 = buildColumn(pet, "growth", pet => pet.weight / pet.age)
+  // Test the inferred type:
+  val _: (kind: String, age: Int, weight: Double, growth: Double) = pet2
+  // Show the results
+  println(pet.mkString)
+  println(pet2.mkString)
+
+