experiment with into type conversion

.github/workflows/test.yml

@@ -12,4 +12,5 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: coursier/cache-action@v6
+      - run: ./format_src_check.sh
       - run: ./mill __.test

.scalafix.conf

@@ -7,7 +7,7 @@ OrganizeImports {
   groupedImports = Merge
   groups = [
     "java."
-    "cats."
+    "scala."
     "forja."
     "*"
   ]

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.10.1"
+version = "3.11.2"
 runner.dialect = scala3
 
 assumeStandardLibraryStripMargin = true

build.mill

@@ -11,7 +11,7 @@ import mill.api.Task.Simple
 import mill.api.TaskCtx
 
 trait ForjaModule extends ScalaModule, ScalafixModule:
-  def scalaVersion = "3.8.3"
+  def scalaVersion = "3.8.4"
   def scalacOptions = Seq(
     // "-Werror",
     "-Yexplicit-nulls",
@@ -20,7 +20,9 @@ trait ForjaModule extends ScalaModule, ScalafixModule:
     "-source:future",
     "-Xcheck-macros",
     "-explain-cyclic",
+    "-Wunused:imports",
     "-preview",
+    "-language:experimental.erasedDefinitions",
   )
   override def forkArgs = super.forkArgs() ++ Seq(
     // TODO: fix when Scala 3.8?
@@ -41,75 +43,7 @@ end ForjaModule
 
 object forja extends ForjaModule:
   override def mvnDeps = Seq(
-    mvn"com.lihaoyi::sourcecode:0.4.4",
-    mvn"com.lihaoyi::os-lib:0.11.5",
-    mvn"org.typelevel::cats-core:2.13.0",
-    mvn"io.github.java-diff-utils:java-diff-utils:4.15",
-    mvn"dev.zio::izumi-reflect:3.0.9",
+    // TODO: when we need dependencies back
   )
   object test extends ForjaTests
-
-  private enum State:
-    case Normal, NextLineIsTemplate
-    case IsReplacing(count: Int)
-
-  def updateLimit22Apply(check: Boolean = false) = Task.Command:
-    allSourceFiles().foreach: src =>
-      var didReplace = false
-      var state = State.Normal
-      val replacedLines =
-        os.read.lines
-          .stream(src.path)
-          .flatMap:
-            case line @ s"$_// %%replicate22" if state == State.Normal =>
-              didReplace = true
-              state = State.NextLineIsTemplate
-              List(line)
-            case line if state == State.NextLineIsTemplate =>
-              state = State.IsReplacing(0)
-              var template = line
-              line +: (3 to 22).map: i =>
-                template = template
-                  .replace(s"T${i - 1}, U]", s"T${i - 1}, T$i, U]")
-                  .replace(
-                    s"t${i - 1}: T${i - 1})",
-                    s"t${i - 1}: T${i - 1}, t$i: T$i)",
-                  )
-                  .replace(
-                    s"t${i - 1}: C ?=> T${i - 1})",
-                    s"t${i - 1}: C ?=> T${i - 1}, t$i: C ?=> T$i)",
-                  )
-                  .replace(s"T${i - 1})", s"T${i - 1}, T$i)")
-                  .replace(s"t${i - 1})", s"t${i - 1}, t$i)")
-                  .replace(s"T${i - 1}]", s"T${i - 1}, T$i]")
-                template
-            case line @ s"$_// format: on"
-                if state.isInstanceOf[State.IsReplacing] =>
-              state = State.Normal
-              List(line)
-            case line if state.isInstanceOf[State.IsReplacing] =>
-              assert(state.asInstanceOf[State.IsReplacing].count <= 20)
-              state = State.IsReplacing(
-                state.asInstanceOf[State.IsReplacing].count + 1,
-              )
-              Nil
-            case line if state == State.Normal =>
-              List(line)
-            case line =>
-              assert(false, s"(in state $state) $line")
-          .toSeq
-
-      if check && didReplace && replacedLines != os.read.lines(src.path)
-      then TaskCtx.taskCtx.fail(s"out of date: ${src.path}")
-      if check
-      then println(s"ok ${src.path}")
-      else if didReplace && replacedLines != os.read.lines(src.path)
-      then
-        println(s"rewrite ${src.path}")
-        os.write.over(
-          src.path,
-          replacedLines.view.flatMap(line => List(line, System.lineSeparator())),
-        )
-      else println(s"no change ${src.path}")
-  end updateLimit22Apply
 end forja

forja/src/CalcEval.scala

@@ -0,0 +1,54 @@
+package forja
+
+trait Calc extends Lang:
+  object Num extends Lang.Term[(n: Int)]
+
+  object Expr extends Lang.Sum:
+    sealed trait Case extends Lang.Node
+    object Triv extends Lang.Term[(value: Num.T)], Case
+    object Add extends Lang.Term[(lhs: Expr.T, rhs: Expr.T)], Case
+    object Mul extends Lang.Term[(lhs: Expr.T, rhs: Expr.T)], Case
+  end Expr
+end Calc
+object Calc extends Calc
+
+trait Val extends Lang:
+  object Num extends Lang.Term[(n: Int)]
+end Val
+object Val extends Val
+
+object CalcEval:
+  given (
+      xform: => Lang.Transform[Calc.Expr.type, Val.Num.type],
+  ) => Lang.Rewrite[Calc.Expr.T, Val.Num.T]:
+    def rewrite(t: Calc.Expr.T): Val.Num.T =
+      t.ex match
+        case Calc.Expr.Add((l, r)) =>
+          val Val.Num(Tuple1(ln)) = xform.transform(l).runtimeChecked
+          val Val.Num(Tuple1(rn)) = xform.transform(r).runtimeChecked
+          Val.Num((n = ln + rn))
+        case Calc.Expr.Mul((l, r)) =>
+          val Val.Num(Tuple1(ln)) = xform.transform(l).runtimeChecked
+          val Val.Num(Tuple1(rn)) = xform.transform(r).runtimeChecked
+          Val.Num((n = ln * rn))
+        case Calc.Expr.Triv(Tuple1(Calc.Num(Tuple1(n)))) => Val.Num((n = n))
+
+  private val xform = summon[Lang.Transform[Calc.Expr.type, Val.Num.type]]
+
+  def eval(expr: Calc.Expr.T): Val.Num.T =
+    xform.transform(expr)
+
+  def main(args: Array[String]): Unit =
+    val e1 = Calc.Expr.Add(
+      lhs = Calc.Expr.Triv((value = Calc.Num((n = 2)))),
+      rhs = Calc.Expr.Triv((value = Calc.Num((n = 3)))),
+    )
+    println(s"2 + 3 = ${eval(e1)}")
+
+    val e2 = Calc.Expr.Mul(
+      lhs = Calc.Expr.Triv((value = Calc.Num((n = 4)))),
+      rhs = Calc.Expr.Triv((value = Calc.Num((n = 5)))),
+    )
+    println(s"4 * 5 = ${eval(e2)}")
+  end main
+end CalcEval

forja/src/CalcXform.scala

@@ -0,0 +1,56 @@
+package forja
+
+trait SubLang extends Lang:
+  object Num extends Lang.Term[(n: Int)]
+
+  object Expr extends Lang.Sum:
+    sealed trait Case extends Lang.Node
+    object Triv extends Lang.Term[(value: Num.T)], Case
+    object Sub extends Lang.Term[(lhs: Expr.T, rhs: Expr.T)], Case
+    object Add extends Lang.Term[(lhs: Expr.T, rhs: Expr.T)], Case
+    object Mul extends Lang.Term[(lhs: Expr.T, rhs: Expr.T)], Case
+  end Expr
+end SubLang
+object SubLang extends SubLang
+
+trait AddLang extends Lang.Extend[SubLang]:
+  export up.{Expr as _, *}
+
+  object Expr extends up.Expr.Extends:
+    sealed trait Case extends Lang.Node
+    export up.Expr.{Triv, Add, Mul}
+  end Expr
+
+  given up.Expr.Sub.Retract
+end AddLang
+object AddLang extends AddLang
+
+object CalcXform:
+  given (
+      xform: => Lang.Transform[SubLang.Expr.type, AddLang.Expr.type],
+  ) => Lang.Rewrite[SubLang.Expr.Sub.T, AddLang.Expr.T]:
+    def rewrite(t: SubLang.Expr.Sub.T): AddLang.Expr.T =
+      val SubLang.Expr.Sub((l, r)) = t.runtimeChecked
+      AddLang.Expr.Add(
+        lhs = xform.transform(l),
+        rhs = AddLang.Expr.Mul(
+          lhs = AddLang.Expr.Triv((value = AddLang.Num((n = -1)))),
+          rhs = xform.transform(r),
+        ),
+      )
+
+  private val xform =
+    summon[Lang.Transform[SubLang.Expr.type, AddLang.Expr.type]]
+
+  def transform(expr: SubLang.Expr.T): AddLang.Expr.T =
+    xform.transform(expr)
+
+  def main(args: Array[String]): Unit =
+    val e1 = SubLang.Expr.Sub(
+      lhs = SubLang.Expr.Triv((value = SubLang.Num((n = 2)))),
+      rhs = SubLang.Expr.Triv((value = SubLang.Num((n = 3)))),
+    )
+    println(e1)
+    println(transform(e1))
+  end main
+end CalcXform