Version 1.5.1.

- Update Scala to 3.3.5
- Some internals slightly rewritten; no change to API.

Author: Michel Charpentier

S/src/main/scala/tinyscalautils/control/interruptibly.scala

@@ -21,49 +21,50 @@ private inline def check[A](inline code: A): A =
 @throws[InterruptedException]
 inline def interruptibly[A](inline code: A): A = check(code)
 
-extension [I, O](f: I => O)
-   /** @define text1
-     *   Makes a function responsive to interrupts: `f.interruptibly` has the same behavior as `f`
-     *   except that it checks for interrupts before each invocation. Additionally,
-     *   `f.interruptibly` checks for interrupts once, before the resulting function is used.
-     *
-     * @note
-     *   This is only implemented for functions of arity 1 and 2. For higher arities, one can use
-     *   `untupled(f.tupled.interruptibly)`.
-     *
-     * @since 1.5
-     *
-     * $text1
-     */
-   @throws[InterruptedException]
-   def interruptibly: I => O = check(x => check(f(x)))
+given InterruptiblyExtensions: AnyRef with
+   extension [I, O](f: I => O)
+      /** @define text1
+        *   Makes a function responsive to interrupts: `f.interruptibly` has the same behavior as
+        *   `f` except that it checks for interrupts before each invocation. Additionally,
+        *   `f.interruptibly` checks for interrupts once, before the resulting function is used.
+        *
+        * @note
+        *   This is only implemented for functions of arity 1 and 2. For higher arities, one can use
+        *   `untupled(f.tupled.interruptibly)`.
+        *
+        * @since 1.5
+        *
+        * $text1
+        */
+      @throws[InterruptedException]
+      def interruptibly: I => O = check(x => check(f(x)))
 
-extension [I1, I2, O](f: (I1, I2) => O)
-   /** $text1 */
-   @throws[InterruptedException]
-   def interruptibly: (I1, I2) => O = check((x, y) => check(f(x, y)))
+   extension [I1, I2, O](f: (I1, I2) => O)
+      /** $text1 */
+      @throws[InterruptedException]
+      def interruptibly: (I1, I2) => O = check((x, y) => check(f(x, y)))
 
-extension [I, O1, O2](h: (I => O1) => O2)
-   /** @define text2
-     *   Makes the function argument of a higher-order function `h` responsive to interrupts:
-     *   `h.interruptiby(f)` is equivalent to `h(f.interruptibly)` but is more convenient when `f`
-     *   is defined as a lambda expression, e.g.: `list.forall.interruptibly(x => x > 0)`.
-     *
-     * @note
-     *   This handling of higher-order functions only works with arguments `f` or arity 1 and
-     *   2. If `f` is a 3-argument function, for instance, `h.interruptibly(f)` is equivalent to
-     *      `interruptibly(h(f))` instead. To achieved the desired behavior, one can use
-     *      `h(untupled(f.tupled.interruptibly))`.
-     *
-     * @since 1.5
-     *
-     * $text2
-     */
-   @throws[InterruptedException]
-   def interruptibly(using DummyImplicit): (I => O1) => O2 = f => h(f.interruptibly)
+   extension [I, O1, O2](h: (I => O1) => O2)(using DummyImplicit)
+      /** @define text2
+        *   Makes the function argument of a higher-order function `h` responsive to interrupts:
+        *   `h.interruptiby(f)` is equivalent to `h(f.interruptibly)` but is more convenient when
+        *   `f` is defined as a lambda expression, e.g.: `list.forall.interruptibly(x => x > 0)`.
+        *
+        * @note
+        *   This handling of higher-order functions only works with arguments `f` or arity 1 and
+        *   2. If `f` is a 3-argument function, for instance, `h.interruptibly(f)` is equivalent to
+        *      `interruptibly(h(f))` instead. To achieved the desired behavior, one can use
+        *      `h(untupled(f.tupled.interruptibly))`.
+        *
+        * @since 1.5
+        *
+        * $text2
+        */
+      @throws[InterruptedException]
+      def interruptibly: (I => O1) => O2 = f => h(f.interruptibly)
 
-extension [I1, I2, O1, O2](h: ((I1, I2) => O1) => O2)
-   /** $text2 */
-   @throws[InterruptedException]
-   def interruptibly(using d1: DummyImplicit, d2: DummyImplicit): ((I1, I2) => O1) => O2 =
-      f => h(f.interruptibly)
+   extension [I1, I2, O1, O2](h: ((I1, I2) => O1) => O2)(using d1: DummyImplicit, d2: DummyImplicit)
+      /** $text2 */
+      @throws[InterruptedException]
+      def interruptibly: ((I1, I2) => O1) => O2 =
+         f => h(f.interruptibly)

S/src/main/scala/tinyscalautils/util/FastRandom.scala

@@ -39,6 +39,10 @@ end FastRandom
 object FastRandom extends FastRandom(ThreadLocalRandomAdapter):
    assert(java.lang.Double.parseDouble("0x1.0p-24f").doubleValue == 5.9604644775390625E-8f)
 
+   /** Interruptible variant, same as the `interruptible` extension, but cached for performance. */
+   lazy val interruptible: Random = InterruptibleRandom(this)
+end FastRandom
+
 /* It'd be nice to merge the two adapter classes into one (their methods are identical),
  * but the type for `rand` would have to be `RandomGenerator`, which does not exist in Java 11.
  */

S/src/test/scala/tinyscalautils/InterruptiblySuite.scala

@@ -0,0 +1,37 @@
+package tinyscalautils
+
+import org.scalatest.funsuite.AnyFunSuite
+
+// outside control package to test givens
+
+class InterruptiblySuite extends AnyFunSuite:
+   test("plain"):
+      import tinyscalautils.control.interruptibly
+      assert(interruptibly("X") == "X")
+      Thread.currentThread.interrupt()
+      assertThrows[InterruptedException](interruptibly("X"))
+      assert(!Thread.currentThread.isInterrupted)
+
+   test("functions"):
+      import tinyscalautils.control.InterruptiblyExtensions
+      val list = List(1, 2, 3)
+      assert(list.map.interruptibly(_ + 1) == List(2, 3, 4))
+      Thread.currentThread.interrupt()
+      assertThrows[InterruptedException](list.map.interruptibly(_ + 1))
+      assert(!Thread.currentThread.isInterrupted)
+
+   test("ambiguous 1"):
+      import tinyscalautils.control.interruptibly
+      val set = Set(1, 2, 3)
+      assert(interruptibly(set) == Set(1, 2, 3))
+
+   test("ambiguous 2"):
+      import tinyscalautils.control.InterruptiblyExtensions
+      val set = Set(1, 2, 3)
+      assert(set.interruptibly(2))
+
+   test("ambiguous 3"):
+      import tinyscalautils.control.{ InterruptiblyExtensions, interruptibly }
+      val set = Set(1, 2, 3)
+      assert(interruptibly(set) == Set(1, 2, 3))
+      assert(set.interruptibly(2))

T/src/main/scala/tinyscalautils/test/grading/GradingSuites.scala

@@ -10,10 +10,10 @@ open class GradingSuites private (
     override val nestedSuites: IndexedSeq[GradingSuite]
 ) extends GradingSuite:
 
-   /** Creates a combined suite.Its weight is the sum of the weights of the nested suites. */
+   /** Creates a combined suite. Its weight is given and must be positive. */
    def this(weight: Double)(suites: GradingSuite*) = this(weight, suites.toIndexedSeq)
 
-   /** Creates a combined suite. Its weight is given and must be positive. */
+   /** Creates a combined suite.Its weight is the sum of the weights of the nested suites. */
    def this(suites: GradingSuite*) = this(0.0, suites.toIndexedSeq)
 
    val grader: Grader = Graders()

build.sbt

@@ -1,8 +1,8 @@
 val ScalaTest = "org.scalatest"    %% "scalatest-funsuite" % "3.2.19"
 val JUnit     = "org.junit.jupiter" % "junit-jupiter"      % "5.11.4"
 
-ThisBuild / version       := "1.5.0"
-ThisBuild / scalaVersion  := "3.3.4"
+ThisBuild / version       := "1.5.1"
+ThisBuild / scalaVersion  := "3.3.5"
 ThisBuild / versionScheme := Some("semver-spec")
 
 ThisBuild / Test / fork                 := true