Scala 3 support!

Author: japgolly

.github/workflows/ci.yml

@@ -12,8 +12,10 @@ jobs:
     strategy:
       matrix:
         include:
-          - java: 8
+          - java: 14
             scala: 2.13.6
+          - java: 8
+            scala: 3.0.1
 
     steps:
       - name: Git checkout

core/shared/src/main/scala/teststate/dsl/HasErrorString.scala

@@ -0,0 +1,10 @@
+package teststate.dsl
+
+trait HasErrorString {
+  def errorString: String
+}
+
+object HasErrorString {
+  implicit def formatHasErrorString(e: HasErrorString): String =
+    e.errorString
+}

core/shared/src/main/scala/teststate/dsl/package.scala

@@ -9,12 +9,12 @@ import utest._
 
 object ActionTest extends TestSuite {
 
-  val * = Dsl[Unit, Unit, Unit]
+  val dsl = Dsl[Unit, Unit, Unit]
 
-  val a1 = *.action("A1")(_ => ())
-  val a2 = *.action("A2")(_ => ())
-  val a3 = *.action("A3")(_ => ())
-  val c1 = *.chooseAction("C1")(_ => a1)
+  val a1 = dsl.action("A1")(_ => ())
+  val a2 = dsl.action("A2")(_ => ())
+  val a3 = dsl.action("A3")(_ => ())
+  val c1 = dsl.chooseAction("C1")(_ => a1)
   val g1 = (a1 >> a2).group("G1")
 
   override def tests = Tests {

core/shared/src/test/scala/teststate/ActionTest.scala

@@ -4,23 +4,23 @@ import cats.instances.string._
 import nyaya.prop._
 import nyaya.test.PropTest._
 import teststate.Exports._
-import teststate.RandomData.*
 import teststate.TestUtil._
 import teststate.typeclass.PolyComposable
 import teststate.typeclass.PolyComposable.{Can, SeqOp}
 import utest._
 
 object CompositionTest extends TestSuite {
+  import teststate.RandomData.dsl
 
   def associativity[A, B, C, AB, BC](implicit
                                      x1: PolyComposable[SeqOp, A, B, AB],
                                      x2: PolyComposable[SeqOp, B, C, BC],
-                                     x3: PolyComposable[SeqOp, AB, C, *.Actions],
-                                     x4: PolyComposable[SeqOp, A, BC, *.Actions]) = {
+                                     x3: PolyComposable[SeqOp, AB, C, dsl.Actions],
+                                     x4: PolyComposable[SeqOp, A, BC, dsl.Actions]) = {
 
     implicit def anyCanSeq[X]: Can[SeqOp, X] = Can
 
-    def results(a: *.Actions): String =
+    def results(a: dsl.Actions): String =
       "\n" + Plan.action(a).stateless.testU.runU().format(inspectionFormat)
 
     Prop.equal[(A, B, C)]("associativity")(

core/shared/src/test/scala/teststate/CompositionTest.scala

@@ -10,12 +10,12 @@ object CoproductExample {
   }
 
   object Txt {
-    val * = Dsl[Txt, String, String]
+    val dsl = Dsl[Txt, String, String]
 
-    val txt = *.focus("Txt value").obsAndState(identity, identity)
+    val txt = dsl.focus("Txt value").obsAndState(identity, identity)
 
     def add(a: String) =
-      *.action("Add")(_.ref.txt += a).updateState(_ + a)
+      dsl.action("Add")(_.ref.txt += a).updateState(_ + a)
         .addCheck(txt.assert.equal.beforeAndAfter)
 
     val test = Plan.action(add("x").times(2)).test(Observer(_.txt))
@@ -26,12 +26,12 @@ object CoproductExample {
   }
 
   object Num {
-    val * = Dsl[Num, Int, Int]
+    val dsl = Dsl[Num, Int, Int]
 
-    val num = *.focus("Number value").obsAndState(identity, identity)
+    val num = dsl.focus("Number value").obsAndState(identity, identity)
 
     def add(a: Int) =
-      *.action("Add")(_.ref.num += a).updateState(_ + a)
+      dsl.action("Add")(_.ref.num += a).updateState(_ + a)
         .addCheck(num.assert.equal.beforeAndAfter)
 
     val test = Plan.action(add(2).times(2)).test(Observer(_.num))
@@ -69,9 +69,9 @@ object CoproductExample {
     case class State(t: Type, num: Int, txt: String)
     type Obs = Int Either String
 
-    val * = Dsl[Top, Obs, State]
+    val dsl = Dsl[Top, Obs, State]
 
-    val curType = *.focus("Current type").obsAndState[Type]({
+    val curType = dsl.focus("Current type").obsAndState[Type]({
       case Left(_) => Type.Num
       case Right(_) => Type.Txt
     }, _.t)
@@ -108,9 +108,9 @@ object CoproductExample {
       curType.assert.equal
 
     val swapTypes =
-      *.action("Swap types")(_.ref.swap()).updateStateBy(i => i.state.copy(t = i.state.t.swap))
+      dsl.action("Swap types")(_.ref.swap()).updateStateBy(i => i.state.copy(t = i.state.t.swap))
 
-    val actions: *.Actions =
+    val actions: dsl.Actions =
       testNum >> swapTypes >> testTxt
 
     val test = Plan(actions, invariants).test(

core/shared/src/test/scala/teststate/CoproductExample.scala

@@ -8,7 +8,7 @@ import utest._
 
 object DslTest extends TestSuite {
 
-  val * = Dsl[Unit, Unit, Unit]
+  val dsl = Dsl[Unit, Unit, Unit]
 
 //  def extract1[A, B](s: Sack[A, B]): B =
 //     s match {
@@ -37,36 +37,36 @@ object DslTest extends TestSuite {
   override def tests = Tests {
 
     "changeTo" - {
-      "pos" - testName(*.focus("Counter").value(_ => 7).assert.changeTo(_ + 1),
+      "pos" - testName(dsl.focus("Counter").value(_ => 7).assert.changeTo(_ + 1),
         "Counter should be <?>.",
         "Counter should be 8.")
 
-      "neg" - testName(*.focus("Counter").value(_ => 7).assert.not.changeTo(_ + 1),
+      "neg" - testName(dsl.focus("Counter").value(_ => 7).assert.not.changeTo(_ + 1),
         "Counter shouldn't be <?>.",
         "Counter shouldn't be 8.")
 
       // TODO Didn't catch. Try using changeTo in multiple actions and verify final history. Might be Name strictness.
     }
 
     "incrementBy" - {
-      "pos" - testName(*.focus("Counter").value(_ => 7).assert.increaseBy(2),
+      "pos" - testName(dsl.focus("Counter").value(_ => 7).assert.increaseBy(2),
         "Counter should increase by 2.",
         "Counter should increase by 2.")
 //        "Counter should be 9.")
 
-      "neg" - testName(*.focus("Counter").value(_ => 7).assert.not.increaseBy(2),
+      "neg" - testName(dsl.focus("Counter").value(_ => 7).assert.not.increaseBy(2),
         "Counter shouldn't increase by 2.",
         "Counter shouldn't increase by 2.")
 //        "Counter shouldn't be 9.")
     }
 
     "decrementBy" - {
-      "pos" - testName(*.focus("Counter").value(_ => 7).assert.decreaseBy(2),
+      "pos" - testName(dsl.focus("Counter").value(_ => 7).assert.decreaseBy(2),
         "Counter should decrease by 2.",
         "Counter should decrease by 2.")
 //        "Counter should be 5.")
 
-      "neg" - testName(*.focus("Counter").value(_ => 7).assert.not.decreaseBy(2),
+      "neg" - testName(dsl.focus("Counter").value(_ => 7).assert.not.decreaseBy(2),
         "Counter shouldn't decrease by 2.",
         "Counter shouldn't decrease by 2.")
 //        "Counter shouldn't be 5.")