add embeds to CalcEvaluator

fhackett · fhackett · commit eed269fc5130 · 2025-05-29T07:21:58.000Z
diff --git a/langs/calc/CalcEvaluator.scala b/langs/calc/CalcEvaluator.scala
@@ -30,103 +30,72 @@ object CalcEvaluator extends PassSeq:
   def inputWellformed: Wellformed = lang.wf
 
   val passes = List(
-    SimplifyPass,
-    RemoveLayerPass,
+    ConstantsPass,
+    EvaluatorPass,
+    StripExpressionPass,
   )
 
-  object SimplifyPass extends PassSeq.Pass:
+  object ConstantsPass extends Pass:
     val wellformed = prevWellformed.makeDerived:
-      Node.Top ::=! Expression
+      Expression.removeCases(Number)
+      Expression.addCases(EmbedMeta[Int])
+    val rules = pass(once = true, strategy = pass.bottomUp)
+      .rules:
+        on(
+          tok(Expression) *> onlyChild(tok(Number)),
+        ).rewrite: num =>
+          splice(Expression(Node.Embed(num.sourceRange.decodeString().toInt)))
+
+  object EvaluatorPass extends Pass:
+    val wellformed = prevWellformed.makeDerived:
+      Expression ::=! embedded[Int]
     val rules = pass(once = false, strategy = pass.bottomUp)
       .rules:
         on(
-          field(tok(Expression)) *> onlyChild(
+          tok(Expression) *> onlyChild(
             tok(Add).withChildren:
-              field(tok(Expression) *> onlyChild(tok(Number)))
-                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+              field(tok(Expression) *> onlyChild(embed[Int]))
+                ~ field(tok(Expression) *> onlyChild(embed[Int]))
                 ~ eof,
           ),
         ).rewrite: (left, right) =>
-          val leftNum = left.unparent().sourceRange.decodeString().toInt
-          val rightNum = right.unparent().sourceRange.decodeString().toInt
-
-          splice(
-            Expression(
-              Number(
-                (leftNum + rightNum).toString(),
-              ),
-            ),
-          )
+          splice(Expression(Node.Embed[Int](left + right)))
         | on(
-          field(tok(Expression)) *> onlyChild(
+          tok(Expression) *> onlyChild(
             tok(Sub).withChildren:
-              field(tok(Expression) *> onlyChild(tok(Number)))
-                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+              field(tok(Expression) *> onlyChild(embed[Int]))
+                ~ field(tok(Expression) *> onlyChild(embed[Int]))
                 ~ eof,
           ),
         ).rewrite: (left, right) =>
-          val leftNum = left.unparent().sourceRange.decodeString().toInt
-          val rightNum = right.unparent().sourceRange.decodeString().toInt
-
-          splice(
-            Expression(
-              Number(
-                (leftNum - rightNum).toString(),
-              ),
-            ),
-          )
+          splice(Expression(Node.Embed[Int](left - right)))
         | on(
-          field(tok(Expression)) *> onlyChild(
+          tok(Expression) *> onlyChild(
             tok(Mul).withChildren:
-              field(tok(Expression) *> onlyChild(tok(Number)))
-                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+              field(tok(Expression) *> onlyChild(embed[Int]))
+                ~ field(tok(Expression) *> onlyChild(embed[Int]))
                 ~ eof,
           ),
         ).rewrite: (left, right) =>
-          val leftNum = left.unparent().sourceRange.decodeString().toInt
-          val rightNum = right.unparent().sourceRange.decodeString().toInt
-
-          splice(
-            Expression(
-              Number(
-                (leftNum * rightNum).toString(),
-              ),
-            ),
-          )
+          splice(Expression(Node.Embed[Int](left * right)))
         | on(
-          field(tok(Expression)) *> onlyChild(
+          tok(Expression) *> onlyChild(
             tok(Div).withChildren:
-              field(tok(Expression) *> onlyChild(tok(Number)))
-                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+              field(tok(Expression) *> onlyChild(embed[Int]))
+                ~ field(tok(Expression) *> onlyChild(embed[Int]))
                 ~ eof,
           ),
         ).rewrite: (left, right) =>
-          val leftNum = left.unparent().sourceRange.decodeString().toInt
-          val rightNum = right.unparent().sourceRange.decodeString().toInt
-
-          splice(
-            Expression(
-              Number(
-                (leftNum / rightNum).toString(),
-              ),
-            ),
-          )
+          splice(Expression(Node.Embed[Int](left / right)))
     end rules
-  end SimplifyPass
+  end EvaluatorPass
 
-  object RemoveLayerPass extends Pass:
+  object StripExpressionPass extends Pass:
     val wellformed = prevWellformed.makeDerived:
-      Node.Top ::=! Number
-    val rules = pass(once = true, strategy = pass.topDown)
+      Node.Top ::=! embedded[Int]
+    val rules = pass(once = true, strategy = pass.bottomUp)
       .rules:
-        on(
-          tok(Expression).withChildren:
-            field(tok(Number))
-              ~ eof,
-        ).rewrite: (number) =>
-          splice(
-            number.unparent(),
-          )
-    end rules
-  end RemoveLayerPass
+        on(tok(Expression) *> onlyChild(embed[Int])).rewrite: i =>
+          splice(Node.Embed(i))
+  end StripExpressionPass
 end CalcEvaluator
diff --git a/langs/calc/README.md b/langs/calc/README.md
@@ -27,7 +27,8 @@ The ```rules``` method uses byte-level pattern matching to create tokens for num
 
 The wellformed definition adds new ```Operation``` token types that have 2 ```Expression``` children. Also, ```Expression``` tokens have a new definition, being able to wrap both ```Number``` tokens as well as ```Operation``` tokens.
 
-```mulDivPass``` and ```addSubPass``` both create nested expressions and splicing the old ```Op``` tokens that were previously defined. Both methods do this by pattern matching on the sequence of ```(Expression, Op, Expression)``` and replacing this sequence with
+The passes are a sequence of transformations defined in the `passes` field, in this consisting of 2 binary operation parsing passes.
+```MulDivPass``` and ```AddSubPass``` both create nested expressions and splicing the old ```Op``` tokens that were previously defined. Both methods do this by pattern matching on the sequence of ```(Expression, Op, Expression)``` and replacing this sequence with
 
 ```
 Expression(
@@ -38,38 +39,21 @@ Expression(
 )
 ```
 
-```mulDivPass``` is executed before ```addSubPass``` to create precedence, allowing multiplication and division operations to be nested deeper than addition and subtraction operations in the AST. 
+```MulDivPass``` is executed before ```AddSubPass``` to create precedence, allowing multiplication and division operations to be nested deeper than addition and subtraction operations in the AST. 
 
 
 ### 4. ```CalcEvaluator.scala```
 ```CalcEvaluator``` simplifies the AST and computes the value of the arithmetic expression.
 
 The wellformed definition is imported from ```package.scala```, picking up with the AST structure of where ```CalcParser``` left off.
-
-```simplifyPass``` splices all expressions repeatedly until there's only a single expression node at the top of the AST structure. The pass uses a bottom-up strategy to begin with simplifying the base-case expressions with no nesting as it goes up the AST. 
-
-The pass sequence pattern matches on
-
-```
-Expression(
-    Operation(
-        Expression(
-            Number
-        ),
-        Expression(
-            Number
-        )
-    )
-)
-```
-
-and replaces the sequence with ```Expression(Number)```. The remaining ```Expression``` token at the end of the pass contains the value of arithmetic expression.
-
-```removeLayerPass``` splices the ```Expression``` token at the top of the AST and replaces it with the ```Number``` token that was wrapped inside. Pattern matching is done on the sequence of ```Expression(Number)``` and replaces it with just ```Number```.
+Each pass is annotated with its own input / output grammars, expressed as changes to the previous pass's output grammar.
+- `ConstantsPass` converts each number to a native Scala `Int` for easier arithmetic, showing an example of the `Node.Embed` feature.
+- `EvaluatorPass` is a ruleset that describes basic arithmetic evaluation, which will fold a wellformed tree into a single node of the form `Expression(Node.Embed[Int](???))`.
+- `StripExpressionPass` simply cleans up the previous pass's tree, leaving just `Node.Embed[Int](???)` containing the result of evaluating the expression.
 
 
 ## Usage
-To learn how to use the calculator, ```CalcReader.test.scala``` contains methods (```parse```, ```read```, ```evaluate```) that execute the different components of the calculator.
+To learn how to use the calculator, ```package.test.scala``` contains methods (```parse```, ```read```, ```evaluate```) that execute the different components of the calculator.
 
 
 ## Example
diff --git a/langs/calc/package.test.scala b/langs/calc/package.test.scala
@@ -15,11 +15,13 @@
 package forja.langs.calc
 
 import forja.*
+import forja.dsl.*
+import forja.manip.RewriteDebugTracer
 import forja.source.{Source, SourceRange}
 
 import Builtin.{Error, SourceMarker}
 
-class CalcReaderTests extends munit.FunSuite:
+class CalcTests extends munit.FunSuite:
   extension (str: String)
     def read: Node.Top =
       forja.langs.calc.read
@@ -45,8 +47,8 @@ class CalcReaderTests extends munit.FunSuite:
       val top = parse
 
       // format: off
-      // instrumentWithTracer(Manip.RewriteDebugTracer(os.pwd / "dbg_calc_evaluator_passes")):
-      CalcEvaluator(top)
+      instrumentWithTracer(RewriteDebugTracer(os.pwd / "dbg_calc_evaluator_passes")):
+        CalcEvaluator(top)
       // format: on
 
       // os.write.over(
@@ -265,46 +267,46 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 + 11".evaluate,
       Node.Top(
-        lang.Number("16"),
+        Node.Embed(16),
       ),
     )
 
   test("multiplication calculation"):
     assertEquals(
       "5 * 11".evaluate,
       Node.Top(
-        lang.Number("55"),
+        Node.Embed(55),
       ),
     )
 
   test("full calculation"):
     assertEquals(
       "5 + 11 * 4".evaluate,
       Node.Top(
-        lang.Number("49"),
+        Node.Embed(49),
       ),
     )
 
   test("full calculation 2"):
     assertEquals(
       "5 * 4 + 4 / 2".evaluate,
       Node.Top(
-        lang.Number("22"),
+        Node.Embed(22),
       ),
     )
 
   test("full calculation 3"):
     assertEquals(
       "5 * 4 + 4 / 2 - 6".evaluate,
       Node.Top(
-        lang.Number("16"),
+        Node.Embed(16),
       ),
     )
 
   test("full calculation 4"):
     assertEquals(
       "5 * 4 + 4 / 2 - 6 * 2".evaluate,
       Node.Top(
-        lang.Number("10"),
+        Node.Embed(10),
       ),
     )
diff --git a/src/EmbedMeta.test.scala b/src/EmbedMeta.test.scala
@@ -0,0 +1,61 @@
+// Copyright 2024-2025 Forja Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package forja
+
+import forja.dsl.*
+
+class EmbedMetaTests extends munit.FunSuite:
+  test("int == int"):
+    assert(EmbedMeta[Int] == EmbedMeta[Int])
+
+  test("int != long"):
+    assert(EmbedMeta[Int] != EmbedMeta[Long])
+
+  val n42 = Node.Embed(42)
+
+  test("node with int"):
+    assert(n42.meta == EmbedMeta[Int])
+
+  test("pattern match"):
+    // for parent purposes
+    val top = Node.Top(n42)
+
+    val manip =
+      initNode(n42):
+        on(embed[Int]).value
+
+    assertEquals(manip.perform(), 42)
+
+    // try rewriting, to be sure
+    val manip2 =
+      initNode(n42):
+        pass(strategy = pass.bottomUp, once = true)
+          .rules:
+            on(embed[Int]).rewrite: i =>
+              splice(Node.Embed(43))
+
+    manip2.perform()
+
+    assertEquals(top, Node.Top(Node.Embed(43)))
+
+  // test("serialization"):
+  /* val serialized =
+   * Source.fromWritable(n42.toCompactWritable(Wellformed.empty)) */
+  //   val tree = sexpr.parse.fromSourceRange(SourceRange.entire(serialized))
+  //   val desern42 = Wellformed.empty.deserializeTree(tree)
+  //   assertEquals(desern42, n42)
+
+  // test("embed toString"):
+  //   assertEquals(Node.Embed(42).toString(), "")
diff --git a/src/manip/SeqPatternOps.scala b/src/manip/SeqPatternOps.scala
@@ -184,6 +184,11 @@ trait SeqPatternOps:
   def lastChild[T](using DebugInfo)(pattern: SeqPattern[T]): SeqPattern[T] =
     refine(atLastChild(on(pattern).value))
 
+  def embed[T: EmbedMeta](using DebugInfo): SeqPattern[T] =
+    anyChild.restrict:
+      case embed @ Node.Embed(t) if embed.meta == EmbedMeta[T] =>
+        t.asInstanceOf[T]
+
   extension [P <: Node.Parent](parentPattern: SeqPattern[P])
     def withChildren[T](using
         DebugInfo,
diff --git a/src/wf/Wellformed.scala b/src/wf/Wellformed.scala
@@ -541,7 +541,7 @@ object Wellformed:
           /* maybe it helps to assert something here, but it is technically
            * correct to just do nothing */
 
-      def addCases(cases: Token*): Unit =
+      def addCases(cases: (Token | EmbedMeta[?])*): Unit =
         existingShape match
           case Shape.Choice(choices) =>
             token ::=! Shape.Choice(choices ++ cases)
