From bdb335d827f03715db73fa395a260e1c9d5fdec9 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Mon, 9 Dec 2024 02:23:00 -0500
Subject: [PATCH 01/11] initial calculator - uses pure scala rather than dcal
 node

---
 calc/CalcReader.scala      | 79 ++++++++++++++++++++++++++++++++++++++
 calc/CalcReader.test.scala | 40 +++++++++++++++++++
 2 files changed, 119 insertions(+)
 create mode 100644 calc/CalcReader.scala
 create mode 100644 calc/CalcReader.test.scala

diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
new file mode 100644
index 0000000..2434f21
--- /dev/null
+++ b/calc/CalcReader.scala
@@ -0,0 +1,79 @@
+package distcompiler.calc
+
+import cats.syntax.all.given
+
+import distcompiler.*
+import distcompiler.Builtin.{Error, SourceMarker}
+import Reader.*
+
+object CalcReader:
+  private val digit: Set[Char] = ('0' to '9').toSet
+  private val operations: Set[Char] = Set('+', '-', '*', '/')
+  private val whitespace: Set[Char] = Set(' ', '\n', '\t')
+
+  sealed trait ParsedToken
+  case class Num(value: Int) extends ParsedToken
+  case class Operation(value: Char) extends ParsedToken
+
+  def tokenize(input: String): List[ParsedToken] = {
+    val (tokens, leftoverBuffer) = input.foldLeft(List.empty[ParsedToken] -> new StringBuilder) {
+      case ((tokenList, numberBuffer), char) if digit.contains(char) =>
+        (tokenList, numberBuffer.append(char))
+
+      case ((tokenList, numberBuffer), char) if operations.contains(char) =>
+        val tokensWithNumbers = if (numberBuffer.nonEmpty)
+          tokenList :+ Num(numberBuffer.toString().toInt)
+        else tokenList
+        (tokensWithNumbers :+ Operation(char), new StringBuilder)
+
+      case((tokenList, numberBuffer), char) if whitespace.contains(char) =>
+        val tokensWithNumbers = if (numberBuffer.nonEmpty)
+          tokenList :+ Num(numberBuffer.toString().toInt)
+        else tokenList
+        (tokensWithNumbers, new StringBuilder)
+
+      case _ => throw IllegalArgumentException("Invalid character")
+    }
+
+    tokens ++ (if (leftoverBuffer.nonEmpty) List(Num(leftoverBuffer.toString().toInt)) else Nil)
+  }
+
+  def evaluate(tokens: List[ParsedToken]): Int = {
+    def precedence(operator: Char): Int = operator match {
+      case '*' | '/'  => 1
+      case '+' | '-'  => 0
+    }
+
+    def applyOperation(a: Int, b: Int, op: Char): Int = op match {
+      case '+' => a + b
+      case '-' => a - b
+      case '*' => a * b
+      case '/' => if (b != 0) a / b else throw ArithmeticException("Division by zero")
+    }
+
+    val (values, ops) = (
+      new scala.collection.mutable.Stack[Int](),
+      new scala.collection.mutable.Stack[Char]()
+    )
+
+    tokens.foreach {
+      case Num(value) => 
+        values.push(value)
+      
+      case Operation(op) =>
+        while (ops.nonEmpty && precedence(ops.top) >= precedence(op)) {
+          val b = values.pop()
+          val a = values.pop()
+          values.push(applyOperation(a, b, ops.pop()))
+        }
+        ops.push(op)
+    }
+
+    while (ops.nonEmpty) {
+      val b = values.pop()
+      val a = values.pop()
+      values.push(applyOperation(a, b, ops.pop()))
+    }
+
+    values.pop()
+  }
\ No newline at end of file
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
new file mode 100644
index 0000000..83ba407
--- /dev/null
+++ b/calc/CalcReader.test.scala
@@ -0,0 +1,40 @@
+package distcompiler.calc
+
+import distcompiler.*
+import Builtin.{Error, SourceMarker}
+
+class CalcReaderTests extends munit.FunSuite:
+  extension (str: String)
+    def evaluate: Int = CalcReader.evaluate(CalcReader.tokenize(str))
+
+  // TODO:
+    // support negative numbers
+    // support brackets for precedence
+
+  test("single number"):
+    assertEquals("42".evaluate, 42)
+
+  test("simple addition"):
+    assertEquals("10 + 5".evaluate, 15)
+
+  test("multi-digit subtraction"):
+    assertEquals("5 - 3 - 2".evaluate, 0)
+
+  test("multi-digit multiplication"):
+    assertEquals("5 * 2 * 11".evaluate, 110)
+
+  test("simple division"):
+    assertEquals("10 / 2".evaluate, 5)
+
+  test("multiplication + division"):
+    assertEquals("10 * 5 / 2".evaluate, 25)
+
+  test("invalid character error"):
+    intercept[IllegalArgumentException] (
+      "5k * 10".evaluate
+    )
+
+  test("divide by zero error"):
+    intercept[ArithmeticException] (
+      "5 / 0".evaluate
+    )

From 3eac302c04bfbfd210d46f1ad61c3412b779aac2 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Fri, 3 Jan 2025 22:20:58 -0500
Subject: [PATCH 02/11] working calculator without proper pass rules

---
 calc/CalcReader.scala      | 200 ++++++++++++++++++++++++-------------
 calc/CalcReader.test.scala |  65 ++++++++----
 calc/package.scala         |  22 ++++
 3 files changed, 201 insertions(+), 86 deletions(-)
 create mode 100644 calc/package.scala

diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index 2434f21..2fbb30f 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -6,74 +6,140 @@ import distcompiler.*
 import distcompiler.Builtin.{Error, SourceMarker}
 import Reader.*
 
-object CalcReader:
+object CalcReader extends Reader:
+  import distcompiler.dsl.*
+  import distcompiler.Builtin.{Error, SourceMarker}
+  import Reader.*
+
+  def wellformed: Wellformed = distcompiler.calc.wellformed
+
   private val digit: Set[Char] = ('0' to '9').toSet
-  private val operations: Set[Char] = Set('+', '-', '*', '/')
+  private val operation: Set[Char] = Set('*', '/', '+', '-')
   private val whitespace: Set[Char] = Set(' ', '\n', '\t')
 
-  sealed trait ParsedToken
-  case class Num(value: Int) extends ParsedToken
-  case class Operation(value: Char) extends ParsedToken
-
-  def tokenize(input: String): List[ParsedToken] = {
-    val (tokens, leftoverBuffer) = input.foldLeft(List.empty[ParsedToken] -> new StringBuilder) {
-      case ((tokenList, numberBuffer), char) if digit.contains(char) =>
-        (tokenList, numberBuffer.append(char))
-
-      case ((tokenList, numberBuffer), char) if operations.contains(char) =>
-        val tokensWithNumbers = if (numberBuffer.nonEmpty)
-          tokenList :+ Num(numberBuffer.toString().toInt)
-        else tokenList
-        (tokensWithNumbers :+ Operation(char), new StringBuilder)
-
-      case((tokenList, numberBuffer), char) if whitespace.contains(char) =>
-        val tokensWithNumbers = if (numberBuffer.nonEmpty)
-          tokenList :+ Num(numberBuffer.toString().toInt)
-        else tokenList
-        (tokensWithNumbers, new StringBuilder)
-
-      case _ => throw IllegalArgumentException("Invalid character")
-    }
-
-    tokens ++ (if (leftoverBuffer.nonEmpty) List(Num(leftoverBuffer.toString().toInt)) else Nil)
-  }
-
-  def evaluate(tokens: List[ParsedToken]): Int = {
-    def precedence(operator: Char): Int = operator match {
-      case '*' | '/'  => 1
-      case '+' | '-'  => 0
-    }
-
-    def applyOperation(a: Int, b: Int, op: Char): Int = op match {
-      case '+' => a + b
-      case '-' => a - b
-      case '*' => a * b
-      case '/' => if (b != 0) a / b else throw ArithmeticException("Division by zero")
-    }
-
-    val (values, ops) = (
-      new scala.collection.mutable.Stack[Int](),
-      new scala.collection.mutable.Stack[Char]()
-    )
-
-    tokens.foreach {
-      case Num(value) => 
-        values.push(value)
+  private lazy val unexpectedEOF: Manip[SourceRange] =
+    consumeMatch: m =>
+      addChild(Error("unexpected EOF", SourceMarker(m)))
+        *> Manip.pure(m)
+
+  protected lazy val rules: Manip[SourceRange] =
+    commit:
+      bytes
+        .selecting[SourceRange]
+        .onOneOf(whitespace):
+          extendThisNodeWithMatch(rules)
+        .onOneOf(digit):
+          numberMode
+        .onOneOf(operation):
+          operationMode
+        .fallback:
+          bytes.selectCount(1):
+            consumeMatch: m =>
+              addChild(Error("invalid byte", SourceMarker(m)))
+                *> rules
+          | consumeMatch: m =>
+            on(theTop).check
+              *> Manip.pure(m)
+          | unexpectedEOF
+
+  private lazy val numberMode: Manip[SourceRange] =
+    commit:
+      bytes
+        .selecting[SourceRange]
+        .onOneOf(digit)(numberMode)
+        .fallback:
+          consumeMatch: m =>
+            m.decodeString().toIntOption match
+              case Some(value) =>
+                addChild(tokens.Atom(m))
+                  *> rules
+              case None =>
+                addChild(Error("invalid number format", SourceMarker(m)))
+                  *> rules
+
+  private lazy val operationMode: Manip[SourceRange] =
+    commit:
+      consumeMatch: m =>
+        addChild(tokens.Atom(m))
+          *> rules
+
+  def evaluate(top: Node.Top): Int =
+    val tokens = top.children.iterator.map(n => 
+      n.asNode.sourceRange.decodeString().trim
+    ).toList
+
+    def validateTokens(tokens: List[String]): Unit =
+      if tokens.isEmpty then 
+        throw IllegalArgumentException("Empty expression")
+      
+      if !tokens.head.forall(_.isDigit) then 
+        throw IllegalArgumentException("Expression must start with a number")
       
-      case Operation(op) =>
-        while (ops.nonEmpty && precedence(ops.top) >= precedence(op)) {
-          val b = values.pop()
-          val a = values.pop()
-          values.push(applyOperation(a, b, ops.pop()))
-        }
-        ops.push(op)
-    }
-
-    while (ops.nonEmpty) {
-      val b = values.pop()
-      val a = values.pop()
-      values.push(applyOperation(a, b, ops.pop()))
-    }
-
-    values.pop()
-  }
\ No newline at end of file
+      if !tokens.last.forall(_.isDigit) then 
+        throw IllegalArgumentException("Expression must end with a number")
+      
+      val isValid = tokens.zipWithIndex.forall { case (token, i) =>
+        if i % 2 == 0 then 
+          token.forall(_.isDigit)
+        else 
+          Set("+", "-", "*", "/").contains(token)
+      }
+      
+      if !isValid then 
+        throw IllegalArgumentException("Invalid expression: must alternate between numbers and operators")
+
+    def evalOp(left: Int, op: String, right: Int): Int = op match
+      case "*" => left * right
+      case "/" => 
+        if right == 0 then throw new ArithmeticException("Division by zero")
+        left / right
+      case "+" => left + right
+      case "-" => left - right
+      case _ => throw new IllegalArgumentException(s"Invalid operator: $op")
+
+    def evaluateWithPrecedence(tokens: List[String]): Int =
+      def evalMulDiv(tokens: List[String]): List[String] =
+        def isNumber(s: String) = s.forall(_.isDigit)
+        
+        tokens match
+          case num1 :: "*" :: num2 :: rest if isNumber(num1) && isNumber(num2) =>
+            val result = evalOp(num1.toInt, "*", num2.toInt)
+            evalMulDiv(result.toString :: rest)
+          
+          case num1 :: "/" :: num2 :: rest if isNumber(num1) && isNumber(num2) =>
+            val result = evalOp(num1.toInt, "/", num2.toInt)
+            evalMulDiv(result.toString :: rest)
+          
+          // if not multiplication or division, keep first token and process rest
+          case firstToken :: remainingTokens => 
+            firstToken :: evalMulDiv(remainingTokens)
+          
+          case Nil => Nil
+
+      val afterMulDiv = evalMulDiv(tokens)
+      afterMulDiv.sliding(3, 2).foldLeft(afterMulDiv.head.toInt) {
+        case (acc, List(_, "+", right)) => acc + right.toInt
+        case (acc, List(_, "-", right)) => acc - right.toInt
+        case (acc, _) => acc
+      }
+
+    validateTokens(tokens)
+    evaluateWithPrecedence(tokens)
+
+  // def evaluate(top: Node.Top): Int =
+  //   def evalNode(nodes: Iterator[Node.Child]): Int =
+  //     if !nodes.hasNext then 0
+  //     else
+  //       var result = nodes.next().asNode.sourceRange.decodeString().trim.toInt
+  //       while nodes.hasNext do
+  //         val op = nodes.next().asNode.sourceRange.decodeString().trim.head
+  //         if !nodes.hasNext then
+  //           throw new IllegalArgumentException("Expression ends with an operator")
+  //         val next = nodes.next().asNode.sourceRange.decodeString().trim.toInt
+  //         op match
+  //           case '+' => result = result + next
+  //           case '-' => result = result - next
+  //           case _ => throw new IllegalArgumentException("Invalid equation provided")
+  //       result
+
+  //   evalNode(top.children.iterator)
\ No newline at end of file
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index 83ba407..ff4cd35 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -5,36 +5,63 @@ import Builtin.{Error, SourceMarker}
 
 class CalcReaderTests extends munit.FunSuite:
   extension (str: String)
-    def evaluate: Int = CalcReader.evaluate(CalcReader.tokenize(str))
+    def parse: Node.Top =
+      calc.parse.fromSourceRange(SourceRange.entire(Source.fromString(str)))
 
-  // TODO:
-    // support negative numbers
-    // support brackets for precedence
+    def evaluate: Int = 
+      val top = calc.parse.fromSourceRange(SourceRange.entire(Source.fromString(str)))
+      CalcReader.evaluate(top)
+
+  test("empty string"):
+    assertEquals("".parse, Node.Top())
+
+  test("only whitespace"):
+    assertEquals("    \n\t".parse, Node.Top())
+
+  test("error: invalid character"):
+    assertEquals("k".parse, Node.Top(Error("invalid byte", SourceMarker("k"))))
 
   test("single number"):
-    assertEquals("42".evaluate, 42)
+    assertEquals(
+      "5".parse, 
+      Node.Top(
+        tokens.Atom("5")
+      )
+    )
 
   test("simple addition"):
-    assertEquals("10 + 5".evaluate, 15)
+    assertEquals(
+      "5 + 11".parse, 
+      Node.Top(
+        tokens.Atom("5"),
+        tokens.Atom("+"),
+        tokens.Atom("11")
+      )
+    )
+
+  test("addition calculation"):
+    assertEquals("5 + 11".evaluate, 16)
 
-  test("multi-digit subtraction"):
-    assertEquals("5 - 3 - 2".evaluate, 0)
+  test("calculation"):
+    assertEquals("10 - 7 + 4".evaluate, 7)
 
-  test("multi-digit multiplication"):
-    assertEquals("5 * 2 * 11".evaluate, 110)
+  test("error: incorrect format"):
+    intercept[IllegalArgumentException] (
+      "10 - 10 7".evaluate
+    )
 
-  test("simple division"):
-    assertEquals("10 / 2".evaluate, 5)
+  test("multiplication calculation"):
+    assertEquals("12 * 5 / 2".evaluate, 30)
 
-  test("multiplication + division"):
-    assertEquals("10 * 5 / 2".evaluate, 25)
+  test("error: divide by zero"):
+    intercept[ArithmeticException] (
+      "16 * 2 / 0".evaluate
+    )
 
-  test("invalid character error"):
+  test("error: invalid character error"):
     intercept[IllegalArgumentException] (
       "5k * 10".evaluate
     )
 
-  test("divide by zero error"):
-    intercept[ArithmeticException] (
-      "5 / 0".evaluate
-    )
+  test("full calculation"):
+    assertEquals("10 + 7 * 5 - 9 / 3".evaluate, 42)
\ No newline at end of file
diff --git a/calc/package.scala b/calc/package.scala
new file mode 100644
index 0000000..b2f3578
--- /dev/null
+++ b/calc/package.scala
@@ -0,0 +1,22 @@
+package distcompiler.calc
+
+import cats.syntax.all.given
+
+import scala.collection.mutable
+
+import distcompiler.*
+import dsl.*
+
+object tokens:
+  object Atom extends Token:
+    override def showSource: Boolean = true
+
+val wellformed: Wellformed =
+  Wellformed:
+    val listContents = repeated(choice(tokens.Atom))
+    Node.Top ::= listContents
+    tokens.Atom ::= Atom
+
+object parse:
+  def fromSourceRange(sourceRange: SourceRange): Node.Top =
+    CalcReader(sourceRange)
\ No newline at end of file

From 329fa5f797e803bf0047bd6d63cd347687d687a7 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Mon, 13 Jan 2025 16:22:15 -0500
Subject: [PATCH 03/11] leveraging passes with rewrite rules

---
 calc/CalcParser.scala      |  64 +++++++++++++++++++++++
 calc/CalcReader.scala      | 104 ++++++-------------------------------
 calc/CalcReader.test.scala |  53 +++++++++----------
 calc/package.scala         |  24 +++++++--
 4 files changed, 126 insertions(+), 119 deletions(-)
 create mode 100644 calc/CalcParser.scala

diff --git a/calc/CalcParser.scala b/calc/CalcParser.scala
new file mode 100644
index 0000000..1a04f5d
--- /dev/null
+++ b/calc/CalcParser.scala
@@ -0,0 +1,64 @@
+package distcompiler.calc
+
+import cats.syntax.all.given
+
+import distcompiler.*
+import dsl.*
+import distcompiler.Builtin.{Error, SourceMarker}
+
+object CalcParser extends PassSeq:
+  import distcompiler.dsl.*
+  import distcompiler.Builtin.{Error, SourceMarker}
+  import Reader.*
+
+  def inputWellformed: Wellformed = CalcReader.wellformed
+
+  private lazy val mulDivPass = passDef:
+    wellformed := prevWellformed.makeDerived:
+      Node.Top ::=! repeated(choice(tokens.Operation, tokens.Number))
+
+    pass(once = false, strategy = pass.topDown)
+      .rules:
+        on(
+          tok(tokens.Operation).filter(node => 
+            Set("*", "/").contains(node.sourceRange.decodeString().trim)
+          ).withChildren(
+            field(tokens.Number)
+              ~ field(tokens.Operator) 
+              ~ field(tokens.Number)
+              ~ trailing
+          )
+        ).rewrite: (left, op, right) =>
+          val l = left.sourceRange.decodeString().toInt
+          val r = right.sourceRange.decodeString().toInt
+          val result = op.sourceRange.decodeString().trim match
+            case "*" => l * r
+            case "/" => 
+              if r == 0 then throw ArithmeticException("Division by zero")
+              l / r
+          
+          splice(tokens.Number(result.toString))
+
+  private lazy val addSubPass = passDef:
+    wellformed := prevWellformed.makeDerived:
+      Node.Top ::=! fields(tokens.Number)
+
+    pass(once = false, strategy = pass.topDown)
+      .rules:
+        on(
+          tok(tokens.Operation).filter(node =>
+            Set("+", "-").contains(node.sourceRange.decodeString().trim)  
+          ).withChildren(
+            field(tokens.Number)
+              ~ field(tokens.Operator)
+              ~ field(tokens.Number)
+              ~ trailing
+          )
+        ).rewrite: (left, op, right) =>
+          val l = left.sourceRange.decodeString().toInt
+          val r = right.sourceRange.decodeString().toInt
+          val result = op.sourceRange.decodeString().trim match
+            case "+" => l + r
+            case "-" => l - r
+          
+          splice(tokens.Number(result.toString))
\ No newline at end of file
diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index 2fbb30f..ac0875c 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -3,15 +3,22 @@ package distcompiler.calc
 import cats.syntax.all.given
 
 import distcompiler.*
+import dsl.*
 import distcompiler.Builtin.{Error, SourceMarker}
 import Reader.*
 
 object CalcReader extends Reader:
-  import distcompiler.dsl.*
-  import distcompiler.Builtin.{Error, SourceMarker}
-  import Reader.*
-
-  def wellformed: Wellformed = distcompiler.calc.wellformed
+  override lazy val wellformed = Wellformed:
+    Node.Top ::= repeated(choice(tokens.Number, tokens.Operator))
+    
+    tokens.Number ::= Atom
+    tokens.Operator ::= Atom
+    
+    tokens.Operation ::= fields(
+      tokens.Number,
+      tokens.Operator,
+      tokens.Number
+    )
 
   private val digit: Set[Char] = ('0' to '9').toSet
   private val operation: Set[Char] = Set('*', '/', '+', '-')
@@ -51,7 +58,7 @@ object CalcReader extends Reader:
           consumeMatch: m =>
             m.decodeString().toIntOption match
               case Some(value) =>
-                addChild(tokens.Atom(m))
+                addChild(tokens.Number(m))
                   *> rules
               case None =>
                 addChild(Error("invalid number format", SourceMarker(m)))
@@ -60,86 +67,5 @@ object CalcReader extends Reader:
   private lazy val operationMode: Manip[SourceRange] =
     commit:
       consumeMatch: m =>
-        addChild(tokens.Atom(m))
-          *> rules
-
-  def evaluate(top: Node.Top): Int =
-    val tokens = top.children.iterator.map(n => 
-      n.asNode.sourceRange.decodeString().trim
-    ).toList
-
-    def validateTokens(tokens: List[String]): Unit =
-      if tokens.isEmpty then 
-        throw IllegalArgumentException("Empty expression")
-      
-      if !tokens.head.forall(_.isDigit) then 
-        throw IllegalArgumentException("Expression must start with a number")
-      
-      if !tokens.last.forall(_.isDigit) then 
-        throw IllegalArgumentException("Expression must end with a number")
-      
-      val isValid = tokens.zipWithIndex.forall { case (token, i) =>
-        if i % 2 == 0 then 
-          token.forall(_.isDigit)
-        else 
-          Set("+", "-", "*", "/").contains(token)
-      }
-      
-      if !isValid then 
-        throw IllegalArgumentException("Invalid expression: must alternate between numbers and operators")
-
-    def evalOp(left: Int, op: String, right: Int): Int = op match
-      case "*" => left * right
-      case "/" => 
-        if right == 0 then throw new ArithmeticException("Division by zero")
-        left / right
-      case "+" => left + right
-      case "-" => left - right
-      case _ => throw new IllegalArgumentException(s"Invalid operator: $op")
-
-    def evaluateWithPrecedence(tokens: List[String]): Int =
-      def evalMulDiv(tokens: List[String]): List[String] =
-        def isNumber(s: String) = s.forall(_.isDigit)
-        
-        tokens match
-          case num1 :: "*" :: num2 :: rest if isNumber(num1) && isNumber(num2) =>
-            val result = evalOp(num1.toInt, "*", num2.toInt)
-            evalMulDiv(result.toString :: rest)
-          
-          case num1 :: "/" :: num2 :: rest if isNumber(num1) && isNumber(num2) =>
-            val result = evalOp(num1.toInt, "/", num2.toInt)
-            evalMulDiv(result.toString :: rest)
-          
-          // if not multiplication or division, keep first token and process rest
-          case firstToken :: remainingTokens => 
-            firstToken :: evalMulDiv(remainingTokens)
-          
-          case Nil => Nil
-
-      val afterMulDiv = evalMulDiv(tokens)
-      afterMulDiv.sliding(3, 2).foldLeft(afterMulDiv.head.toInt) {
-        case (acc, List(_, "+", right)) => acc + right.toInt
-        case (acc, List(_, "-", right)) => acc - right.toInt
-        case (acc, _) => acc
-      }
-
-    validateTokens(tokens)
-    evaluateWithPrecedence(tokens)
-
-  // def evaluate(top: Node.Top): Int =
-  //   def evalNode(nodes: Iterator[Node.Child]): Int =
-  //     if !nodes.hasNext then 0
-  //     else
-  //       var result = nodes.next().asNode.sourceRange.decodeString().trim.toInt
-  //       while nodes.hasNext do
-  //         val op = nodes.next().asNode.sourceRange.decodeString().trim.head
-  //         if !nodes.hasNext then
-  //           throw new IllegalArgumentException("Expression ends with an operator")
-  //         val next = nodes.next().asNode.sourceRange.decodeString().trim.toInt
-  //         op match
-  //           case '+' => result = result + next
-  //           case '-' => result = result - next
-  //           case _ => throw new IllegalArgumentException("Invalid equation provided")
-  //       result
-
-  //   evalNode(top.children.iterator)
\ No newline at end of file
+        addChild(tokens.Operator(m))
+          *> rules
\ No newline at end of file
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index ff4cd35..d91b503 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -8,9 +8,10 @@ class CalcReaderTests extends munit.FunSuite:
     def parse: Node.Top =
       calc.parse.fromSourceRange(SourceRange.entire(Source.fromString(str)))
 
-    def evaluate: Int = 
-      val top = calc.parse.fromSourceRange(SourceRange.entire(Source.fromString(str)))
-      CalcReader.evaluate(top)
+    def evaluate: Node.Top =
+      val top = parse
+      CalcParser(top)
+      top
 
   test("empty string"):
     assertEquals("".parse, Node.Top())
@@ -25,7 +26,7 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5".parse, 
       Node.Top(
-        tokens.Atom("5")
+        tokens.Number("5")
       )
     )
 
@@ -33,35 +34,35 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 + 11".parse, 
       Node.Top(
-        tokens.Atom("5"),
-        tokens.Atom("+"),
-        tokens.Atom("11")
+        tokens.Number("5"),
+        tokens.Operator("+"),
+        tokens.Number("11")
       )
     )
 
   test("addition calculation"):
-    assertEquals("5 + 11".evaluate, 16)
+    assertEquals("5 + 11".evaluate, Node.Top(tokens.Number("16")))
 
-  test("calculation"):
-    assertEquals("10 - 7 + 4".evaluate, 7)
+  // test("calculation"):
+  //   assertEquals("10 - 7 + 4".evaluate, 7)
 
-  test("error: incorrect format"):
-    intercept[IllegalArgumentException] (
-      "10 - 10 7".evaluate
-    )
+  // test("error: incorrect format"):
+  //   intercept[IllegalArgumentException] (
+  //     "10 - 10 7".evaluate
+  //   )
 
-  test("multiplication calculation"):
-    assertEquals("12 * 5 / 2".evaluate, 30)
+  // test("multiplication calculation"):
+  //   assertEquals("12 * 5 / 2".evaluate, 30)
 
-  test("error: divide by zero"):
-    intercept[ArithmeticException] (
-      "16 * 2 / 0".evaluate
-    )
+  // test("error: divide by zero"):
+  //   intercept[ArithmeticException] (
+  //     "16 * 2 / 0".evaluate
+  //   )
 
-  test("error: invalid character error"):
-    intercept[IllegalArgumentException] (
-      "5k * 10".evaluate
-    )
+  // test("error: invalid character error"):
+  //   intercept[IllegalArgumentException] (
+  //     "5k * 10".evaluate
+  //   )
 
-  test("full calculation"):
-    assertEquals("10 + 7 * 5 - 9 / 3".evaluate, 42)
\ No newline at end of file
+  // test("full calculation"):
+  //   assertEquals("10 + 7 * 5 - 9 / 3".evaluate, 42)
\ No newline at end of file
diff --git a/calc/package.scala b/calc/package.scala
index b2f3578..535b99f 100644
--- a/calc/package.scala
+++ b/calc/package.scala
@@ -8,14 +8,30 @@ import distcompiler.*
 import dsl.*
 
 object tokens:
-  object Atom extends Token:
+  object Operation extends Token
+
+  object Number extends Token:
+    override def showSource: Boolean = true
+
+  object Operator extends Token:
     override def showSource: Boolean = true
 
+  object Result extends Token:
+    override val symbolTableFor: Set[Token] = 
+      Set(Number)
+
 val wellformed: Wellformed =
   Wellformed:
-    val listContents = repeated(choice(tokens.Atom))
-    Node.Top ::= listContents
-    tokens.Atom ::= Atom
+    Node.Top ::= repeated(choice(tokens.Number, tokens.Operator))
+    
+    tokens.Number ::= Atom
+    tokens.Operator ::= Atom
+    
+    tokens.Operation ::= fields(
+      tokens.Number,
+      tokens.Operator,
+      tokens.Number
+    )
 
 object parse:
   def fromSourceRange(sourceRange: SourceRange): Node.Top =

From 16c87aa7f70a9c2058c93119b60c65ead26f57e3 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 19 Feb 2025 13:48:54 -0500
Subject: [PATCH 04/11] changed logic for calculations

---
 calc/CalcParser.scala      | 101 +++++++++++++++++++++++--------------
 calc/CalcReader.scala      |  41 +++++++++------
 calc/CalcReader.test.scala |  77 +++++++++++++++++++++-------
 calc/package.scala         |  28 +++++-----
 4 files changed, 165 insertions(+), 82 deletions(-)

diff --git a/calc/CalcParser.scala b/calc/CalcParser.scala
index 1a04f5d..31d1fbe 100644
--- a/calc/CalcParser.scala
+++ b/calc/CalcParser.scala
@@ -5,60 +5,87 @@ import cats.syntax.all.given
 import distcompiler.*
 import dsl.*
 import distcompiler.Builtin.{Error, SourceMarker}
+import distcompiler.calc.tokens.*
 
 object CalcParser extends PassSeq:
   import distcompiler.dsl.*
-  import distcompiler.Builtin.{Error, SourceMarker}
   import Reader.*
+  import CalcReader.*
 
   def inputWellformed: Wellformed = CalcReader.wellformed
 
-  private lazy val mulDivPass = passDef:
+  private val mulDivPass = passDef:
+    wellformed := inputWellformed.makeDerived:
+      Node.Top ::=! repeated(choice(Number, Expression, LowPrecOp))
+    
+    pass(once = true, strategy = pass.topDown)
+      .rules:
+        on(
+          field(tok(Number, Expression))
+          ~ field(tok(HighPrecOp))
+          ~ field(tok(Number, Expression))
+          ~ trailing
+        ).rewrite: (left, operator, right) =>
+          splice(
+            Expression(
+              left.unparent(),
+              operator.unparent(),
+              right.unparent()
+            )
+          )
+
+  private val addSubPass = passDef:
     wellformed := prevWellformed.makeDerived:
-      Node.Top ::=! repeated(choice(tokens.Operation, tokens.Number))
+      Node.Top ::=! repeated(choice(Number, Expression))
 
-    pass(once = false, strategy = pass.topDown)
+    pass(once = true, strategy = pass.topDown)
       .rules:
         on(
-          tok(tokens.Operation).filter(node => 
-            Set("*", "/").contains(node.sourceRange.decodeString().trim)
-          ).withChildren(
-            field(tokens.Number)
-              ~ field(tokens.Operator) 
-              ~ field(tokens.Number)
-              ~ trailing
+          field(tok(Number, Expression))
+          ~ field(tok(LowPrecOp))
+          ~ field(tok(Number, Expression))
+          ~ trailing
+        ).rewrite: (left, operator, right) =>
+          splice(
+            Expression(
+              left.unparent(),
+              operator.unparent(),
+              right.unparent()
+            )
           )
-        ).rewrite: (left, op, right) =>
-          val l = left.sourceRange.decodeString().toInt
-          val r = right.sourceRange.decodeString().toInt
-          val result = op.sourceRange.decodeString().trim match
-            case "*" => l * r
-            case "/" => 
-              if r == 0 then throw ArithmeticException("Division by zero")
-              l / r
-          
-          splice(tokens.Number(result.toString))
 
-  private lazy val addSubPass = passDef:
+  private val simplifyPass = passDef:
     wellformed := prevWellformed.makeDerived:
-      Node.Top ::=! fields(tokens.Number)
+      Node.Top ::=! fields(Number)
+
+    def evaluateOperation(left: Node, op: Node, right: Node): Int =
+      val leftNum = left.sourceRange.decodeString().toInt
+      val rightNum = right.sourceRange.decodeString().toInt
+      val operation = op.sourceRange.decodeString()
+      
+      operation match
+        case "+" => leftNum + rightNum
+        case "-" => leftNum - rightNum
+        case "*" => leftNum * rightNum
+        case "/" => leftNum / rightNum
+        case _ => throw IllegalArgumentException("Unknown operator")
 
     pass(once = false, strategy = pass.topDown)
       .rules:
         on(
-          tok(tokens.Operation).filter(node =>
-            Set("+", "-").contains(node.sourceRange.decodeString().trim)  
-          ).withChildren(
-            field(tokens.Number)
-              ~ field(tokens.Operator)
-              ~ field(tokens.Number)
-              ~ trailing
+          tok(Expression) *> children(
+            field(tok(Number))
+            ~ field(tok(LowPrecOp, HighPrecOp))
+            ~ field(tok(Number))
+            ~ trailing
           )
         ).rewrite: (left, op, right) =>
-          val l = left.sourceRange.decodeString().toInt
-          val r = right.sourceRange.decodeString().toInt
-          val result = op.sourceRange.decodeString().trim match
-            case "+" => l + r
-            case "-" => l - r
-          
-          splice(tokens.Number(result.toString))
\ No newline at end of file
+          splice(
+            Number(
+              evaluateOperation(
+                left.unparent(),
+                op.unparent(),
+                right.unparent()
+              ).toString
+            )
+          )
\ No newline at end of file
diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index ac0875c..123f9c7 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -6,22 +6,25 @@ import distcompiler.*
 import dsl.*
 import distcompiler.Builtin.{Error, SourceMarker}
 import Reader.*
+import distcompiler.calc.tokens.*
 
 object CalcReader extends Reader:
   override lazy val wellformed = Wellformed:
-    Node.Top ::= repeated(choice(tokens.Number, tokens.Operator))
+    Node.Top ::= repeated(choice(tokens.Number, tokens.Expression, tokens.LowPrecOp, tokens.HighPrecOp))
     
-    tokens.Number ::= Atom
-    tokens.Operator ::= Atom
-    
-    tokens.Operation ::= fields(
-      tokens.Number,
-      tokens.Operator,
-      tokens.Number
+    Number ::= Atom
+    LowPrecOp ::= Atom
+    HighPrecOp ::= Atom
+
+    Expression ::= fields(
+      choice(tokens.Number, tokens.Expression),
+      choice(tokens.LowPrecOp, tokens.HighPrecOp),
+      choice(tokens.Number, tokens.Expression),
     )
 
   private val digit: Set[Char] = ('0' to '9').toSet
-  private val operation: Set[Char] = Set('*', '/', '+', '-')
+  private val lowPrecOperation: Set[Char] = Set('+', '-')
+  private val highPrecOperation: Set[Char] = Set('*', '/')
   private val whitespace: Set[Char] = Set(' ', '\n', '\t')
 
   private lazy val unexpectedEOF: Manip[SourceRange] =
@@ -37,10 +40,12 @@ object CalcReader extends Reader:
           extendThisNodeWithMatch(rules)
         .onOneOf(digit):
           numberMode
-        .onOneOf(operation):
-          operationMode
+        .onOneOf(lowPrecOperation):
+          lowPrecOpMode
+        .onOneOf(highPrecOperation):
+          highPrecOpMode
         .fallback:
-          bytes.selectCount(1):
+          bytes.selectOne:
             consumeMatch: m =>
               addChild(Error("invalid byte", SourceMarker(m)))
                 *> rules
@@ -58,14 +63,20 @@ object CalcReader extends Reader:
           consumeMatch: m =>
             m.decodeString().toIntOption match
               case Some(value) =>
-                addChild(tokens.Number(m))
+                addChild(Number(m))
                   *> rules
               case None =>
                 addChild(Error("invalid number format", SourceMarker(m)))
                   *> rules
 
-  private lazy val operationMode: Manip[SourceRange] =
+  private lazy val lowPrecOpMode: Manip[SourceRange] =
+    commit:
+      consumeMatch: m =>
+        addChild(LowPrecOp(m))
+          *> rules
+
+  private lazy val highPrecOpMode: Manip[SourceRange] =
     commit:
       consumeMatch: m =>
-        addChild(tokens.Operator(m))
+        addChild(HighPrecOp(m))
           *> rules
\ No newline at end of file
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index d91b503..4b61efa 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -10,7 +10,15 @@ class CalcReaderTests extends munit.FunSuite:
 
     def evaluate: Node.Top =
       val top = parse
-      CalcParser(top)
+
+      CalcParser(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_passes"))
+
+      os.write.over(
+        os.pwd / "dbg_calc_parser" / "test_output.dbg",
+        top.toPrettyWritable(CalcReader.wellformed),
+        createFolders = true
+      )
+
       top
 
   test("empty string"):
@@ -35,34 +43,69 @@ class CalcReaderTests extends munit.FunSuite:
       "5 + 11".parse, 
       Node.Top(
         tokens.Number("5"),
-        tokens.Operator("+"),
+        tokens.LowPrecOp("+"),
+        tokens.Number("11")
+      )
+    )
+
+  test("simple multiplication"):
+    assertEquals(
+      "5 * 11".parse, 
+      Node.Top(
+        tokens.Number("5"),
+        tokens.HighPrecOp("*"),
         tokens.Number("11")
       )
     )
 
   test("addition calculation"):
-    assertEquals("5 + 11".evaluate, Node.Top(tokens.Number("16")))
+    assertEquals(
+      "5 + 11".evaluate,
+      Node.Top(
+        tokens.Number("16")
+      ))
 
-  // test("calculation"):
-  //   assertEquals("10 - 7 + 4".evaluate, 7)
+  test("multiplication calculation"):
+    assertEquals(
+      "5 * 11".evaluate,
+      Node.Top(
+        tokens.Number("55")
+      ))
+
+  test("full calculation"):
+    assertEquals(
+      "5 + 11 * 4".evaluate,
+      Node.Top(
+        tokens.Number("49")
+      ))
+
+  test("full calculation 2"):
+    assertEquals(
+      "5 * 4 + 4 / 2".evaluate,
+      Node.Top(
+        tokens.Number("22")
+      ))
+
+  test("full calculation 3"):
+    assertEquals(
+      "5 * 4 + 4 / 2 - 6".evaluate,
+      Node.Top(
+        tokens.Number("16")
+      ))
+
+  test("full calculation 4"):
+    assertEquals(
+      "5 * 4 + 4 / 2 - 6 * 2".evaluate,
+      Node.Top(
+        tokens.Number("10")
+      ))
 
   // test("error: incorrect format"):
   //   intercept[IllegalArgumentException] (
   //     "10 - 10 7".evaluate
   //   )
 
-  // test("multiplication calculation"):
-  //   assertEquals("12 * 5 / 2".evaluate, 30)
-
   // test("error: divide by zero"):
   //   intercept[ArithmeticException] (
   //     "16 * 2 / 0".evaluate
-  //   )
-
-  // test("error: invalid character error"):
-  //   intercept[IllegalArgumentException] (
-  //     "5k * 10".evaluate
-  //   )
-
-  // test("full calculation"):
-  //   assertEquals("10 + 7 * 5 - 9 / 3".evaluate, 42)
\ No newline at end of file
+  //   )
\ No newline at end of file
diff --git a/calc/package.scala b/calc/package.scala
index 535b99f..a1bcca4 100644
--- a/calc/package.scala
+++ b/calc/package.scala
@@ -6,31 +6,33 @@ import scala.collection.mutable
 
 import distcompiler.*
 import dsl.*
+import distcompiler.calc.tokens.*
 
 object tokens:
-  object Operation extends Token
+  object LowPrecOp extends Token:
+    override def showSource: Boolean = true
 
-  object Number extends Token:
+  object HighPrecOp extends Token:
     override def showSource: Boolean = true
 
-  object Operator extends Token:
+  object Expression extends Token:
     override def showSource: Boolean = true
 
-  object Result extends Token:
-    override val symbolTableFor: Set[Token] = 
-      Set(Number)
+  object Number extends Token:
+    override def showSource: Boolean = true
 
 val wellformed: Wellformed =
   Wellformed:
-    Node.Top ::= repeated(choice(tokens.Number, tokens.Operator))
+    Node.Top ::= repeated(choice(tokens.Number, tokens.Expression, tokens.LowPrecOp, tokens.HighPrecOp))
     
     tokens.Number ::= Atom
-    tokens.Operator ::= Atom
-    
-    tokens.Operation ::= fields(
-      tokens.Number,
-      tokens.Operator,
-      tokens.Number
+    tokens.LowPrecOp ::= Atom
+    tokens.HighPrecOp ::= Atom
+
+    tokens.Expression ::= fields(
+      choice(tokens.Number, tokens.Expression),
+      choice(tokens.LowPrecOp, tokens.HighPrecOp),
+      choice(tokens.Number, tokens.Expression),
     )
 
 object parse:

From 5a43bf61a6473f45dc33553695db2b89c3249645 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 26 Feb 2025 13:54:49 -0500
Subject: [PATCH 05/11] added more Token types for stricter pattern matching

---
 calc/CalcParser.scala      |  84 +++++++++++------------
 calc/CalcReader.scala      |  77 +++++++++++++++-------
 calc/CalcReader.test.scala | 132 ++++++++++++++++++++++++++++++++-----
 calc/package.scala         |  59 ++++++++++++++---
 4 files changed, 261 insertions(+), 91 deletions(-)

diff --git a/calc/CalcParser.scala b/calc/CalcParser.scala
index 31d1fbe..457c4ca 100644
--- a/calc/CalcParser.scala
+++ b/calc/CalcParser.scala
@@ -16,76 +16,70 @@ object CalcParser extends PassSeq:
 
   private val mulDivPass = passDef:
     wellformed := inputWellformed.makeDerived:
-      Node.Top ::=! repeated(choice(Number, Expression, LowPrecOp))
+      Node.Top ::=! repeated(choice(Number, Expression, AddOp, SubOp))
     
-    pass(once = true, strategy = pass.topDown)
+    pass(once = false, strategy = pass.topDown)
       .rules:
         on(
           field(tok(Number, Expression))
-          ~ field(tok(HighPrecOp))
+          ~ skip(tok(MulOp))
           ~ field(tok(Number, Expression))
           ~ trailing
-        ).rewrite: (left, operator, right) =>
+        ).rewrite: (left, right) =>
           splice(
             Expression(
-              left.unparent(),
-              operator.unparent(),
-              right.unparent()
+              Mul(
+                left.unparent(),
+                right.unparent()
+              )
             )
           )
-
-  private val addSubPass = passDef:
-    wellformed := prevWellformed.makeDerived:
-      Node.Top ::=! repeated(choice(Number, Expression))
-
-    pass(once = true, strategy = pass.topDown)
-      .rules:
-        on(
+        | on(
           field(tok(Number, Expression))
-          ~ field(tok(LowPrecOp))
+          ~ skip(tok(DivOp))
           ~ field(tok(Number, Expression))
           ~ trailing
-        ).rewrite: (left, operator, right) =>
+        ).rewrite: (left, right) =>
           splice(
             Expression(
-              left.unparent(),
-              operator.unparent(),
-              right.unparent()
+              Div(
+                left.unparent(),
+                right.unparent()
+              )
             )
           )
 
-  private val simplifyPass = passDef:
+  private val addSubPass = passDef:
     wellformed := prevWellformed.makeDerived:
-      Node.Top ::=! fields(Number)
-
-    def evaluateOperation(left: Node, op: Node, right: Node): Int =
-      val leftNum = left.sourceRange.decodeString().toInt
-      val rightNum = right.sourceRange.decodeString().toInt
-      val operation = op.sourceRange.decodeString()
-      
-      operation match
-        case "+" => leftNum + rightNum
-        case "-" => leftNum - rightNum
-        case "*" => leftNum * rightNum
-        case "/" => leftNum / rightNum
-        case _ => throw IllegalArgumentException("Unknown operator")
+      Node.Top ::=! repeated(Expression)
 
     pass(once = false, strategy = pass.topDown)
       .rules:
         on(
-          tok(Expression) *> children(
-            field(tok(Number))
-            ~ field(tok(LowPrecOp, HighPrecOp))
-            ~ field(tok(Number))
-            ~ trailing
+          field(tok(Number, Expression))
+          ~ skip(tok(AddOp))
+          ~ field(tok(Number, Expression))
+          ~ trailing
+        ).rewrite: (left, right) =>
+          splice(
+            Expression(
+              Add(
+                left.unparent(),
+                right.unparent()
+              )
+            )
           )
-        ).rewrite: (left, op, right) =>
+        | on(
+          field(tok(Number, Expression))
+          ~ skip(tok(SubOp))
+          ~ field(tok(Number, Expression))
+          ~ trailing
+        ).rewrite: (left, right) =>
           splice(
-            Number(
-              evaluateOperation(
+            Expression(
+              Sub(
                 left.unparent(),
-                op.unparent(),
                 right.unparent()
-              ).toString
+              )
             )
-          )
\ No newline at end of file
+          )
diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index 123f9c7..c6f0a3d 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -10,21 +10,43 @@ import distcompiler.calc.tokens.*
 
 object CalcReader extends Reader:
   override lazy val wellformed = Wellformed:
-    Node.Top ::= repeated(choice(tokens.Number, tokens.Expression, tokens.LowPrecOp, tokens.HighPrecOp))
+    Node.Top ::= repeated(choice(Number, AddOp, SubOp, MulOp, DivOp))
     
     Number ::= Atom
-    LowPrecOp ::= Atom
-    HighPrecOp ::= Atom
+    AddOp ::= Atom
+    SubOp ::= Atom
+    MulOp ::= Atom
+    DivOp ::= Atom
 
-    Expression ::= fields(
-      choice(tokens.Number, tokens.Expression),
-      choice(tokens.LowPrecOp, tokens.HighPrecOp),
-      choice(tokens.Number, tokens.Expression),
+    Add ::= fields(
+      choice(Number, Expression),
+      choice(Number, Expression)
+    )
+
+    Sub ::= fields(
+      choice(Number, Expression),
+      choice(Number, Expression)
+    )
+
+    Mul ::= fields(
+      choice(Number, Expression),
+      choice(Number, Expression)
+    )
+    
+    Div ::= fields(
+      choice(Number, Expression),
+      choice(Number, Expression)
+    )
+
+    Expression ::= choice(
+      Add,
+      Sub,
+      Mul,
+      Div
     )
 
   private val digit: Set[Char] = ('0' to '9').toSet
-  private val lowPrecOperation: Set[Char] = Set('+', '-')
-  private val highPrecOperation: Set[Char] = Set('*', '/')
+  private val operator: Set[Char] = Set('+', '-', '*', '/')
   private val whitespace: Set[Char] = Set(' ', '\n', '\t')
 
   private lazy val unexpectedEOF: Manip[SourceRange] =
@@ -40,10 +62,8 @@ object CalcReader extends Reader:
           extendThisNodeWithMatch(rules)
         .onOneOf(digit):
           numberMode
-        .onOneOf(lowPrecOperation):
-          lowPrecOpMode
-        .onOneOf(highPrecOperation):
-          highPrecOpMode
+        .onOneOf(operator):
+          operatorMode
         .fallback:
           bytes.selectOne:
             consumeMatch: m =>
@@ -69,14 +89,27 @@ object CalcReader extends Reader:
                 addChild(Error("invalid number format", SourceMarker(m)))
                   *> rules
 
-  private lazy val lowPrecOpMode: Manip[SourceRange] =
-    commit:
-      consumeMatch: m =>
-        addChild(LowPrecOp(m))
-          *> rules
-
-  private lazy val highPrecOpMode: Manip[SourceRange] =
+  private lazy val operatorMode: Manip[SourceRange] =
     commit:
       consumeMatch: m =>
-        addChild(HighPrecOp(m))
-          *> rules
\ No newline at end of file
+        m.decodeString() match
+          case "+" =>
+            addChild(
+              AddOp()
+            )
+              *> rules
+          case "-" =>
+            addChild(
+              SubOp()
+            )
+              *> rules
+          case "*" =>
+            addChild(
+              MulOp()
+            )
+              *> rules
+          case "/" =>
+            addChild(
+              DivOp()
+            )
+              *> rules
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index 4b61efa..fcf3da5 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -5,13 +5,13 @@ import Builtin.{Error, SourceMarker}
 
 class CalcReaderTests extends munit.FunSuite:
   extension (str: String)
-    def parse: Node.Top =
-      calc.parse.fromSourceRange(SourceRange.entire(Source.fromString(str)))
+    def read: Node.Top =
+      calc.read.fromSourceRange(SourceRange.entire(Source.fromString(str)))
 
-    def evaluate: Node.Top =
-      val top = parse
+    def parse: Node.Top = 
+      val top = read
 
-      CalcParser(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_passes"))
+      CalcParser(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_parser_passes"))
 
       os.write.over(
         os.pwd / "dbg_calc_parser" / "test_output.dbg",
@@ -21,43 +21,145 @@ class CalcReaderTests extends munit.FunSuite:
 
       top
 
+    def evaluate: Node.Top = 
+      val top = parse
+
+      CalcEvaluator(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_evaluator_passes"))
+
+      os.write.over(
+        os.pwd / "dbg_calc_evaluator" / "test_output.dbg",
+        top.toPrettyWritable(CalcReader.wellformed),
+        createFolders = true
+      )
+
+      top
+
   test("empty string"):
-    assertEquals("".parse, Node.Top())
+    assertEquals("".read, Node.Top())
 
   test("only whitespace"):
-    assertEquals("    \n\t".parse, Node.Top())
+    assertEquals("    \n\t".read, Node.Top())
 
   test("error: invalid character"):
-    assertEquals("k".parse, Node.Top(Error("invalid byte", SourceMarker("k"))))
+    assertEquals("k".read, Node.Top(Error("invalid byte", SourceMarker("k"))))
 
   test("single number"):
     assertEquals(
-      "5".parse, 
+      "5".read, 
       Node.Top(
         tokens.Number("5")
       )
     )
 
-  test("simple addition"):
+  test("read basic addition"):
     assertEquals(
-      "5 + 11".parse, 
+      "5 + 11".read,
       Node.Top(
         tokens.Number("5"),
-        tokens.LowPrecOp("+"),
+        tokens.AddOp(),
         tokens.Number("11")
       )
     )
 
-  test("simple multiplication"):
+  test("read basic multiplication"):
     assertEquals(
-      "5 * 11".parse, 
+      "5 * 11".read,
       Node.Top(
         tokens.Number("5"),
-        tokens.HighPrecOp("*"),
+        tokens.MulOp(),
         tokens.Number("11")
       )
     )
 
+  test("read full calculation"):
+    assertEquals(
+      "5 + 11 * 4".read,
+      Node.Top(
+        tokens.Number("5"),
+        tokens.AddOp(),
+        tokens.Number("11"),
+        tokens.MulOp(),
+        tokens.Number("4")
+      )
+    )
+
+  test("simple addition parse"):
+    assertEquals(
+      "5 + 11".parse, 
+      Node.Top(
+        tokens.Expression(
+          tokens.Add(
+            tokens.Number("5"),
+            tokens.Number("11")
+          ).at("5 + 11")
+        ).at("5 + 11")
+      )
+    )
+
+  test("simple multiplication parse"):
+    assertEquals(
+      "5 * 11".parse, 
+      Node.Top(
+        tokens.Expression(
+          tokens.Mul(
+            tokens.Number("5"),
+            tokens.Number("11")
+          ).at("5 * 11")
+        ).at("5 * 11")
+      )
+    )
+
+  test("full calculation parse"):
+    assertEquals(
+      "5 + 11 * 4".parse,
+      Node.Top(
+        tokens.Expression(
+          tokens.Add(
+            tokens.Number("5"),
+            tokens.Expression(
+              tokens.Mul(
+                tokens.Number("11"),
+                tokens.Number("4")
+              ).at("11 * 4")
+            ).at("11 * 4")
+          ).at("5 + 11 * 4")
+        ).at("5 + 11 * 4")
+      )
+    )
+
+  test("full calculation 4 parse"):
+    assertEquals(
+      "5 * 4 + 4 / 2 - 6 * 2".parse,
+      Node.Top(
+        tokens.Expression(
+          tokens.Sub(
+            tokens.Expression(
+              tokens.Add(
+                tokens.Expression(
+                  tokens.Mul(
+                    tokens.Number("5"),
+                    tokens.Number("4")
+                  ).at("5 * 4")
+                ).at("5 * 4"),
+                tokens.Expression(
+                  tokens.Div(
+                    tokens.Number("4"),
+                    tokens.Number("2")
+                  ).at("4 / 2")
+                ).at("4 / 2")
+              ).at("5 * 4 + 4 / 2")
+            ).at("5 * 4 + 4 / 2"),
+            tokens.Expression(
+              tokens.Mul(
+                tokens.Number("6"),
+                tokens.Number("2")
+              ).at("6 * 2")
+            ).at("6 * 2")
+          ).at("5 * 4 + 4 / 2 - 6 * 2")
+        ).at("5 * 4 + 4 / 2 - 6 * 2")
+      )
+    )
+
   test("addition calculation"):
     assertEquals(
       "5 + 11".evaluate,
diff --git a/calc/package.scala b/calc/package.scala
index a1bcca4..dbe2a35 100644
--- a/calc/package.scala
+++ b/calc/package.scala
@@ -9,13 +9,31 @@ import dsl.*
 import distcompiler.calc.tokens.*
 
 object tokens:
-  object LowPrecOp extends Token:
+  object Expression extends Token:
     override def showSource: Boolean = true
 
-  object HighPrecOp extends Token:
+  object AddOp extends Token:
     override def showSource: Boolean = true
 
-  object Expression extends Token:
+  object DivOp extends Token:
+    override def showSource: Boolean = true
+
+  object MulOp extends Token:
+    override def showSource: Boolean = true
+
+  object SubOp extends Token:
+    override def showSource: Boolean = true
+
+  object Add extends Token:
+    override def showSource: Boolean = true
+
+  object Sub extends Token:
+    override def showSource: Boolean = true
+
+  object Mul extends Token:
+    override def showSource: Boolean = true
+
+  object Div extends Token:
     override def showSource: Boolean = true
 
   object Number extends Token:
@@ -23,18 +41,41 @@ object tokens:
 
 val wellformed: Wellformed =
   Wellformed:
-    Node.Top ::= repeated(choice(tokens.Number, tokens.Expression, tokens.LowPrecOp, tokens.HighPrecOp))
+    Node.Top ::= repeated(choice(tokens.Number, tokens.AddOp, tokens.SubOp, tokens.MulOp, tokens.DivOp))
     
     tokens.Number ::= Atom
-    tokens.LowPrecOp ::= Atom
-    tokens.HighPrecOp ::= Atom
+    tokens.AddOp ::= Atom
+    tokens.SubOp ::= Atom
+    tokens.MulOp ::= Atom
+    tokens.DivOp ::= Atom
+
+    tokens.Add ::= fields(
+      choice(tokens.Number, tokens.Expression),
+      choice(tokens.Number, tokens.Expression)
+    )
+
+    tokens.Sub ::= fields(
+      choice(tokens.Number, tokens.Expression),
+      choice(tokens.Number, tokens.Expression)
+    )
 
-    tokens.Expression ::= fields(
+    tokens.Mul ::= fields(
       choice(tokens.Number, tokens.Expression),
-      choice(tokens.LowPrecOp, tokens.HighPrecOp),
+      choice(tokens.Number, tokens.Expression)
+    )
+    
+    tokens.Div ::= fields(
       choice(tokens.Number, tokens.Expression),
+      choice(tokens.Number, tokens.Expression)
+    )
+
+    tokens.Expression ::= choice(
+      tokens.Add,
+      tokens.Sub,
+      tokens.Mul,
+      tokens.Div
     )
 
-object parse:
+object read:
   def fromSourceRange(sourceRange: SourceRange): Node.Top =
     CalcReader(sourceRange)
\ No newline at end of file

From faa721c7d59027a9fd73db5dac139e8bbf3e1a50 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 19 Mar 2025 13:59:08 -0400
Subject: [PATCH 06/11] made appropriate changes to wellformed and added
 CalcEvaluator

---
 calc/CalcEvaluator.scala   | 98 ++++++++++++++++++++++++++++++++++++++
 calc/CalcParser.scala      |  2 +-
 calc/CalcReader.scala      | 67 +++++---------------------
 calc/CalcReader.test.scala | 10 ----
 4 files changed, 111 insertions(+), 66 deletions(-)
 create mode 100644 calc/CalcEvaluator.scala

diff --git a/calc/CalcEvaluator.scala b/calc/CalcEvaluator.scala
new file mode 100644
index 0000000..6d1062f
--- /dev/null
+++ b/calc/CalcEvaluator.scala
@@ -0,0 +1,98 @@
+package distcompiler.calc
+
+import cats.syntax.all.given
+
+import distcompiler.*
+import dsl.*
+import distcompiler.Builtin.{Error, SourceMarker}
+import distcompiler.calc.tokens.*
+
+object CalcEvaluator extends PassSeq:
+  import distcompiler.dsl.*
+  import Reader.*
+  import CalcReader.*
+
+  def inputWellformed: Wellformed = CalcParser.outputWellformed
+
+  private val simplifyPass = passDef:
+    wellformed := inputWellformed.makeDerived:
+      Node.Top ::=! fields(Number)
+
+    pass(once = false, strategy = pass.topDown)
+      .rules:
+        on(
+          field(tok(Expression)) *> children(
+            tok(Add).product(children(
+              field(tok(Number))
+              ~ field(tok(Number))
+              ~ eof
+            ))
+          )
+        ).rewrite: (expression, numbers) =>
+          val (left, right) = numbers
+          expression.unparent()
+          val leftNum = left.unparent().sourceRange.decodeString().toInt
+          val rightNum = right.unparent().sourceRange.decodeString().toInt
+
+          splice(
+            Number(
+              (leftNum + rightNum).toString()
+            )
+          )
+        | on(
+          field(tok(Expression)) *> children(
+            tok(Sub).product(children(
+              field(tok(Number))
+              ~ field(tok(Number))
+              ~ eof
+            ))
+          )
+        ).rewrite: (expression, numbers) =>
+          val (left, right) = numbers
+          expression.unparent()
+          val leftNum = left.unparent().sourceRange.decodeString().toInt
+          val rightNum = right.unparent().sourceRange.decodeString().toInt
+
+          splice(
+            Number(
+              (leftNum - rightNum).toString()
+            )
+          )
+        | on(
+          field(tok(Expression)) *> children(
+            tok(Mul).product(children(
+              field(tok(Number))
+              ~ field(tok(Number))
+              ~ eof
+            ))
+          )
+        ).rewrite: (expression, numbers) =>
+          val (left, right) = numbers
+          expression.unparent()
+          val leftNum = left.unparent().sourceRange.decodeString().toInt
+          val rightNum = right.unparent().sourceRange.decodeString().toInt
+
+          splice(
+            Number(
+              (leftNum * rightNum).toString()
+            )
+          )
+        | on(
+          field(tok(Expression)) *> children(
+            tok(Div).product(children(
+              field(tok(Number))
+              ~ field(tok(Number))
+              ~ eof
+            ))
+          )
+        ).rewrite: (expression, numbers) =>
+          val (left, right) = numbers
+          expression.unparent()
+          val leftNum = left.unparent().sourceRange.decodeString().toInt
+          val rightNum = right.unparent().sourceRange.decodeString().toInt
+
+          splice(
+            Number(
+              (leftNum / rightNum).toString()
+            )
+          )
diff --git a/calc/CalcParser.scala b/calc/CalcParser.scala
index 457c4ca..0aef4e3 100644
--- a/calc/CalcParser.scala
+++ b/calc/CalcParser.scala
@@ -12,7 +12,7 @@ object CalcParser extends PassSeq:
   import Reader.*
   import CalcReader.*
 
-  def inputWellformed: Wellformed = CalcReader.wellformed
+  def inputWellformed: Wellformed = distcompiler.calc.wellformed
 
   private val mulDivPass = passDef:
     wellformed := inputWellformed.makeDerived:
diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index c6f0a3d..a85436f 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -18,35 +18,7 @@ object CalcReader extends Reader:
     MulOp ::= Atom
     DivOp ::= Atom
 
-    Add ::= fields(
-      choice(Number, Expression),
-      choice(Number, Expression)
-    )
-
-    Sub ::= fields(
-      choice(Number, Expression),
-      choice(Number, Expression)
-    )
-
-    Mul ::= fields(
-      choice(Number, Expression),
-      choice(Number, Expression)
-    )
-    
-    Div ::= fields(
-      choice(Number, Expression),
-      choice(Number, Expression)
-    )
-
-    Expression ::= choice(
-      Add,
-      Sub,
-      Mul,
-      Div
-    )
-
   private val digit: Set[Char] = ('0' to '9').toSet
-  private val operator: Set[Char] = Set('+', '-', '*', '/')
   private val whitespace: Set[Char] = Set(' ', '\n', '\t')
 
   private lazy val unexpectedEOF: Manip[SourceRange] =
@@ -62,8 +34,18 @@ object CalcReader extends Reader:
           extendThisNodeWithMatch(rules)
         .onOneOf(digit):
           numberMode
-        .onOneOf(operator):
-          operatorMode
+        .on('+'):
+          addChild(AddOp())
+            *> rules
+        .on('-'):
+          addChild(SubOp())
+            *> rules
+        .on('*'):
+          addChild(MulOp())
+            *> rules
+        .on('/'):
+          addChild(DivOp())
+            *> rules
         .fallback:
           bytes.selectOne:
             consumeMatch: m =>
@@ -88,28 +70,3 @@ object CalcReader extends Reader:
               case None =>
                 addChild(Error("invalid number format", SourceMarker(m)))
                   *> rules
-
-  private lazy val operatorMode: Manip[SourceRange] =
-    commit:
-      consumeMatch: m =>
-        m.decodeString() match
-          case "+" =>
-            addChild(
-              AddOp()
-            )
-              *> rules
-          case "-" =>
-            addChild(
-              SubOp()
-            )
-              *> rules
-          case "*" =>
-            addChild(
-              MulOp()
-            )
-              *> rules
-          case "/" =>
-            addChild(
-              DivOp()
-            )
-              *> rules
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index fcf3da5..4db18e4 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -201,13 +201,3 @@ class CalcReaderTests extends munit.FunSuite:
       Node.Top(
         tokens.Number("10")
       ))
-
-  // test("error: incorrect format"):
-  //   intercept[IllegalArgumentException] (
-  //     "10 - 10 7".evaluate
-  //   )
-
-  // test("error: divide by zero"):
-  //   intercept[ArithmeticException] (
-  //     "16 * 2 / 0".evaluate
-  //   )
\ No newline at end of file

From 949c74d4408bb18fe5428991ea50fc0025f3ee67 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Fri, 21 Mar 2025 18:03:31 -0400
Subject: [PATCH 07/11] implemented nested Number & cleaned up main structure

---
 calc/CalcEvaluator.scala   | 120 +++++++++++-------
 calc/CalcParser.scala      |  80 +++++++++---
 calc/CalcReader.scala      |  28 ++++-
 calc/CalcReader.test.scala | 244 ++++++++++++++++++++++++++-----------
 calc/package.scala         |  45 ++++---
 5 files changed, 361 insertions(+), 156 deletions(-)

diff --git a/calc/CalcEvaluator.scala b/calc/CalcEvaluator.scala
index 6d1062f..04c0361 100644
--- a/calc/CalcEvaluator.scala
+++ b/calc/CalcEvaluator.scala
@@ -1,3 +1,17 @@
+// Copyright 2024-2025 DCal 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 distcompiler.calc
 
 import cats.syntax.all.given
@@ -12,87 +26,99 @@ object CalcEvaluator extends PassSeq:
   import Reader.*
   import CalcReader.*
 
-  def inputWellformed: Wellformed = CalcParser.outputWellformed
+  def inputWellformed: Wellformed = distcompiler.calc.wellformed
 
   private val simplifyPass = passDef:
-    wellformed := inputWellformed.makeDerived:
-      Node.Top ::=! fields(Number)
+    wellformed := inputWellformed
 
-    pass(once = false, strategy = pass.topDown)
+    pass(once = false, strategy = pass.bottomUp)
       .rules:
         on(
-          field(tok(Expression)) *> children(
-            tok(Add).product(children(
-              field(tok(Number))
-              ~ field(tok(Number))
-              ~ eof
-            ))
+          field(tok(Expression)) *> onlyChild(
+            tok(Add).withChildren:
+              field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ eof
           )
-        ).rewrite: (expression, numbers) =>
-          val (left, right) = numbers
-          expression.unparent()
+        ).rewrite: (left, right) =>
           val leftNum = left.unparent().sourceRange.decodeString().toInt
           val rightNum = right.unparent().sourceRange.decodeString().toInt
 
           splice(
-            Number(
-              (leftNum + rightNum).toString()
+            Expression(
+              Number(
+                (leftNum + rightNum).toString()
+              )
             )
           )
         | on(
-          field(tok(Expression)) *> children(
-            tok(Sub).product(children(
-              field(tok(Number))
-              ~ field(tok(Number))
-              ~ eof
-            ))
+          field(tok(Expression)) *> onlyChild(
+            tok(Sub).withChildren:
+              field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ eof
           )
-        ).rewrite: (expression, numbers) =>
-          val (left, right) = numbers
-          expression.unparent()
+        ).rewrite: (left, right) =>
           val leftNum = left.unparent().sourceRange.decodeString().toInt
           val rightNum = right.unparent().sourceRange.decodeString().toInt
 
           splice(
-            Number(
-              (leftNum - rightNum).toString()
+            Expression(
+              Number(
+                (leftNum - rightNum).toString()
+              )
             )
           )
         | on(
-          field(tok(Expression)) *> children(
-            tok(Mul).product(children(
-              field(tok(Number))
-              ~ field(tok(Number))
-              ~ eof
-            ))
+          field(tok(Expression)) *> onlyChild(
+            tok(Mul).withChildren:
+              field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ eof
           )
-        ).rewrite: (expression, numbers) =>
-          val (left, right) = numbers
-          expression.unparent()
+        ).rewrite: (left, right) =>
           val leftNum = left.unparent().sourceRange.decodeString().toInt
           val rightNum = right.unparent().sourceRange.decodeString().toInt
 
           splice(
-            Number(
-              (leftNum * rightNum).toString()
+            Expression(
+              Number(
+                (leftNum * rightNum).toString()
+              )
             )
           )
         | on(
-          field(tok(Expression)) *> children(
-            tok(Div).product(children(
-              field(tok(Number))
-              ~ field(tok(Number))
-              ~ eof
-            ))
+          field(tok(Expression)) *> onlyChild(
+            tok(Div).withChildren:
+              field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ field(tok(Expression) *> onlyChild(tok(Number)))
+                ~ eof
           )
-        ).rewrite: (expression, numbers) =>
-          val (left, right) = numbers
-          expression.unparent()
+        ).rewrite: (left, right) =>
           val leftNum = left.unparent().sourceRange.decodeString().toInt
           val rightNum = right.unparent().sourceRange.decodeString().toInt
 
+          splice(
+            Expression(
+              Number(
+                (leftNum / rightNum).toString()
+              )
+            )
+          )
+
+  private val removeLayerPass = passDef:
+    wellformed := inputWellformed.makeDerived:
+      Node.Top ::=! fields(Number)
+
+    pass(once = true, strategy = pass.topDown)
+      .rules:
+        on(
+          tok(Expression).withChildren:
+            field(tok(Number))
+              ~ eof
+        ).rewrite: (number) =>
           splice(
             Number(
-              (leftNum / rightNum).toString()
+              number.unparent().sourceRange.decodeString()
             )
           )
diff --git a/calc/CalcParser.scala b/calc/CalcParser.scala
index 0aef4e3..fde8b10 100644
--- a/calc/CalcParser.scala
+++ b/calc/CalcParser.scala
@@ -1,3 +1,17 @@
+// Copyright 2024-2025 DCal 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 distcompiler.calc
 
 import cats.syntax.all.given
@@ -12,19 +26,47 @@ object CalcParser extends PassSeq:
   import Reader.*
   import CalcReader.*
 
-  def inputWellformed: Wellformed = distcompiler.calc.wellformed
+  def inputWellformed: Wellformed =
+    CalcReader.wellformed.makeDerived:
+      Add ::= fields(
+        Expression,
+        Expression
+      )
+
+      Sub ::= fields(
+        Expression,
+        Expression
+      )
+
+      Mul ::= fields(
+        Expression,
+        Expression
+      )
+
+      Div ::= fields(
+        Expression,
+        Expression
+      )
+
+      Expression ::=! choice(
+        Number,
+        Add,
+        Sub,
+        Mul,
+        Div
+      )
 
   private val mulDivPass = passDef:
     wellformed := inputWellformed.makeDerived:
-      Node.Top ::=! repeated(choice(Number, Expression, AddOp, SubOp))
-    
+      Node.Top ::=! repeated(choice(Expression, AddOp, SubOp))
+
     pass(once = false, strategy = pass.topDown)
       .rules:
         on(
-          field(tok(Number, Expression))
-          ~ skip(tok(MulOp))
-          ~ field(tok(Number, Expression))
-          ~ trailing
+          field(tok(Expression))
+            ~ skip(tok(MulOp))
+            ~ field(tok(Expression))
+            ~ trailing
         ).rewrite: (left, right) =>
           splice(
             Expression(
@@ -35,10 +77,10 @@ object CalcParser extends PassSeq:
             )
           )
         | on(
-          field(tok(Number, Expression))
-          ~ skip(tok(DivOp))
-          ~ field(tok(Number, Expression))
-          ~ trailing
+          field(tok(Expression))
+            ~ skip(tok(DivOp))
+            ~ field(tok(Expression))
+            ~ trailing
         ).rewrite: (left, right) =>
           splice(
             Expression(
@@ -56,10 +98,10 @@ object CalcParser extends PassSeq:
     pass(once = false, strategy = pass.topDown)
       .rules:
         on(
-          field(tok(Number, Expression))
-          ~ skip(tok(AddOp))
-          ~ field(tok(Number, Expression))
-          ~ trailing
+          field(tok(Expression))
+            ~ skip(tok(AddOp))
+            ~ field(tok(Expression))
+            ~ trailing
         ).rewrite: (left, right) =>
           splice(
             Expression(
@@ -70,10 +112,10 @@ object CalcParser extends PassSeq:
             )
           )
         | on(
-          field(tok(Number, Expression))
-          ~ skip(tok(SubOp))
-          ~ field(tok(Number, Expression))
-          ~ trailing
+          field(tok(Expression))
+            ~ skip(tok(SubOp))
+            ~ field(tok(Expression))
+            ~ trailing
         ).rewrite: (left, right) =>
           splice(
             Expression(
diff --git a/calc/CalcReader.scala b/calc/CalcReader.scala
index a85436f..1697eac 100644
--- a/calc/CalcReader.scala
+++ b/calc/CalcReader.scala
@@ -1,3 +1,17 @@
+// Copyright 2024-2025 DCal 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 distcompiler.calc
 
 import cats.syntax.all.given
@@ -10,14 +24,18 @@ import distcompiler.calc.tokens.*
 
 object CalcReader extends Reader:
   override lazy val wellformed = Wellformed:
-    Node.Top ::= repeated(choice(Number, AddOp, SubOp, MulOp, DivOp))
-    
+    Node.Top ::= repeated(choice(Expression, AddOp, SubOp, MulOp, DivOp))
+
     Number ::= Atom
     AddOp ::= Atom
     SubOp ::= Atom
     MulOp ::= Atom
     DivOp ::= Atom
 
+    Expression ::= fields(
+      Number
+    )
+
   private val digit: Set[Char] = ('0' to '9').toSet
   private val whitespace: Set[Char] = Set(' ', '\n', '\t')
 
@@ -65,7 +83,11 @@ object CalcReader extends Reader:
           consumeMatch: m =>
             m.decodeString().toIntOption match
               case Some(value) =>
-                addChild(Number(m))
+                addChild(
+                  Expression(
+                    Number(m)
+                  )
+                )
                   *> rules
               case None =>
                 addChild(Error("invalid number format", SourceMarker(m)))
diff --git a/calc/CalcReader.test.scala b/calc/CalcReader.test.scala
index 4db18e4..3911f74 100644
--- a/calc/CalcReader.test.scala
+++ b/calc/CalcReader.test.scala
@@ -1,3 +1,17 @@
+// Copyright 2024-2025 DCal 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 distcompiler.calc
 
 import distcompiler.*
@@ -8,10 +22,13 @@ class CalcReaderTests extends munit.FunSuite:
     def read: Node.Top =
       calc.read.fromSourceRange(SourceRange.entire(Source.fromString(str)))
 
-    def parse: Node.Top = 
+    def parse: Node.Top =
       val top = read
 
-      CalcParser(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_parser_passes"))
+      CalcParser(
+        top,
+        tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_parser_passes")
+      )
 
       os.write.over(
         os.pwd / "dbg_calc_parser" / "test_output.dbg",
@@ -21,10 +38,13 @@ class CalcReaderTests extends munit.FunSuite:
 
       top
 
-    def evaluate: Node.Top = 
+    def evaluate: Node.Top =
       val top = parse
 
-      CalcEvaluator(top, tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_evaluator_passes"))
+      CalcEvaluator(
+        top,
+        tracer = Manip.RewriteDebugTracer(os.pwd / "dbg_calc_evaluator_passes")
+      )
 
       os.write.over(
         os.pwd / "dbg_calc_evaluator" / "test_output.dbg",
@@ -45,9 +65,11 @@ class CalcReaderTests extends munit.FunSuite:
 
   test("single number"):
     assertEquals(
-      "5".read, 
+      "5".read,
       Node.Top(
-        tokens.Number("5")
+        tokens.Expression(
+          tokens.Number("5")
+        )
       )
     )
 
@@ -55,9 +77,13 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 + 11".read,
       Node.Top(
-        tokens.Number("5"),
+        tokens.Expression(
+          tokens.Number("5")
+        ),
         tokens.AddOp(),
-        tokens.Number("11")
+        tokens.Expression(
+          tokens.Number("11")
+        )
       )
     )
 
@@ -65,9 +91,13 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 * 11".read,
       Node.Top(
-        tokens.Number("5"),
+        tokens.Expression(
+          tokens.Number("5")
+        ),
         tokens.MulOp(),
-        tokens.Number("11")
+        tokens.Expression(
+          tokens.Number("11")
+        )
       )
     )
 
@@ -75,37 +105,59 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 + 11 * 4".read,
       Node.Top(
-        tokens.Number("5"),
+        tokens.Expression(
+          tokens.Number("5")
+        ),
         tokens.AddOp(),
-        tokens.Number("11"),
+        tokens.Expression(
+          tokens.Number("11")
+        ),
         tokens.MulOp(),
-        tokens.Number("4")
+        tokens.Expression(
+          tokens.Number("4")
+        )
       )
     )
 
   test("simple addition parse"):
     assertEquals(
-      "5 + 11".parse, 
+      "5 + 11".parse,
       Node.Top(
-        tokens.Expression(
-          tokens.Add(
-            tokens.Number("5"),
-            tokens.Number("11")
-          ).at("5 + 11")
-        ).at("5 + 11")
+        tokens
+          .Expression(
+            tokens
+              .Add(
+                tokens.Expression(
+                  tokens.Number("5")
+                ),
+                tokens.Expression(
+                  tokens.Number("11")
+                )
+              )
+              .at("5 + 11")
+          )
+          .at("5 + 11")
       )
     )
 
   test("simple multiplication parse"):
     assertEquals(
-      "5 * 11".parse, 
+      "5 * 11".parse,
       Node.Top(
-        tokens.Expression(
-          tokens.Mul(
-            tokens.Number("5"),
-            tokens.Number("11")
-          ).at("5 * 11")
-        ).at("5 * 11")
+        tokens
+          .Expression(
+            tokens
+              .Mul(
+                tokens.Expression(
+                  tokens.Number("5")
+                ),
+                tokens.Expression(
+                  tokens.Number("11")
+                )
+              )
+              .at("5 * 11")
+          )
+          .at("5 * 11")
       )
     )
 
@@ -113,17 +165,31 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 + 11 * 4".parse,
       Node.Top(
-        tokens.Expression(
-          tokens.Add(
-            tokens.Number("5"),
-            tokens.Expression(
-              tokens.Mul(
-                tokens.Number("11"),
-                tokens.Number("4")
-              ).at("11 * 4")
-            ).at("11 * 4")
-          ).at("5 + 11 * 4")
-        ).at("5 + 11 * 4")
+        tokens
+          .Expression(
+            tokens
+              .Add(
+                tokens.Expression(
+                  tokens.Number("5")
+                ),
+                tokens
+                  .Expression(
+                    tokens
+                      .Mul(
+                        tokens.Expression(
+                          tokens.Number("11")
+                        ),
+                        tokens.Expression(
+                          tokens.Number("4")
+                        )
+                      )
+                      .at("11 * 4")
+                  )
+                  .at("11 * 4")
+              )
+              .at("5 + 11 * 4")
+          )
+          .at("5 + 11 * 4")
       )
     )
 
@@ -131,32 +197,64 @@ class CalcReaderTests extends munit.FunSuite:
     assertEquals(
       "5 * 4 + 4 / 2 - 6 * 2".parse,
       Node.Top(
-        tokens.Expression(
-          tokens.Sub(
-            tokens.Expression(
-              tokens.Add(
-                tokens.Expression(
-                  tokens.Mul(
-                    tokens.Number("5"),
-                    tokens.Number("4")
-                  ).at("5 * 4")
-                ).at("5 * 4"),
-                tokens.Expression(
-                  tokens.Div(
-                    tokens.Number("4"),
-                    tokens.Number("2")
-                  ).at("4 / 2")
-                ).at("4 / 2")
-              ).at("5 * 4 + 4 / 2")
-            ).at("5 * 4 + 4 / 2"),
-            tokens.Expression(
-              tokens.Mul(
-                tokens.Number("6"),
-                tokens.Number("2")
-              ).at("6 * 2")
-            ).at("6 * 2")
-          ).at("5 * 4 + 4 / 2 - 6 * 2")
-        ).at("5 * 4 + 4 / 2 - 6 * 2")
+        tokens
+          .Expression(
+            tokens
+              .Sub(
+                tokens
+                  .Expression(
+                    tokens
+                      .Add(
+                        tokens
+                          .Expression(
+                            tokens
+                              .Mul(
+                                tokens.Expression(
+                                  tokens.Number("5")
+                                ),
+                                tokens.Expression(
+                                  tokens.Number("4")
+                                )
+                              )
+                              .at("5 * 4")
+                          )
+                          .at("5 * 4"),
+                        tokens
+                          .Expression(
+                            tokens
+                              .Div(
+                                tokens.Expression(
+                                  tokens.Number("4")
+                                ),
+                                tokens.Expression(
+                                  tokens.Number("2")
+                                )
+                              )
+                              .at("4 / 2")
+                          )
+                          .at("4 / 2")
+                      )
+                      .at("5 * 4 + 4 / 2")
+                  )
+                  .at("5 * 4 + 4 / 2"),
+                tokens
+                  .Expression(
+                    tokens
+                      .Mul(
+                        tokens.Expression(
+                          tokens.Number("6")
+                        ),
+                        tokens.Expression(
+                          tokens.Number("2")
+                        )
+                      )
+                      .at("6 * 2")
+                  )
+                  .at("6 * 2")
+              )
+              .at("5 * 4 + 4 / 2 - 6 * 2")
+          )
+          .at("5 * 4 + 4 / 2 - 6 * 2")
       )
     )
 
@@ -165,39 +263,45 @@ class CalcReaderTests extends munit.FunSuite:
       "5 + 11".evaluate,
       Node.Top(
         tokens.Number("16")
-      ))
+      )
+    )
 
   test("multiplication calculation"):
     assertEquals(
       "5 * 11".evaluate,
       Node.Top(
         tokens.Number("55")
-      ))
+      )
+    )
 
   test("full calculation"):
     assertEquals(
       "5 + 11 * 4".evaluate,
       Node.Top(
         tokens.Number("49")
-      ))
+      )
+    )
 
   test("full calculation 2"):
     assertEquals(
       "5 * 4 + 4 / 2".evaluate,
       Node.Top(
         tokens.Number("22")
-      ))
+      )
+    )
 
   test("full calculation 3"):
     assertEquals(
       "5 * 4 + 4 / 2 - 6".evaluate,
       Node.Top(
         tokens.Number("16")
-      ))
+      )
+    )
 
   test("full calculation 4"):
     assertEquals(
       "5 * 4 + 4 / 2 - 6 * 2".evaluate,
       Node.Top(
         tokens.Number("10")
-      ))
+      )
+    )
diff --git a/calc/package.scala b/calc/package.scala
index dbe2a35..0c13d6d 100644
--- a/calc/package.scala
+++ b/calc/package.scala
@@ -1,3 +1,17 @@
+// Copyright 2024-2025 DCal 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 distcompiler.calc
 
 import cats.syntax.all.given
@@ -10,7 +24,7 @@ import distcompiler.calc.tokens.*
 
 object tokens:
   object Expression extends Token:
-    override def showSource: Boolean = true
+    override def showSource: Boolean = false
 
   object AddOp extends Token:
     override def showSource: Boolean = true
@@ -41,35 +55,32 @@ object tokens:
 
 val wellformed: Wellformed =
   Wellformed:
-    Node.Top ::= repeated(choice(tokens.Number, tokens.AddOp, tokens.SubOp, tokens.MulOp, tokens.DivOp))
-    
+    Node.Top ::= repeated(tokens.Expression)
+
     tokens.Number ::= Atom
-    tokens.AddOp ::= Atom
-    tokens.SubOp ::= Atom
-    tokens.MulOp ::= Atom
-    tokens.DivOp ::= Atom
 
     tokens.Add ::= fields(
-      choice(tokens.Number, tokens.Expression),
-      choice(tokens.Number, tokens.Expression)
+      tokens.Expression,
+      tokens.Expression
     )
 
     tokens.Sub ::= fields(
-      choice(tokens.Number, tokens.Expression),
-      choice(tokens.Number, tokens.Expression)
+      tokens.Expression,
+      tokens.Expression
     )
 
     tokens.Mul ::= fields(
-      choice(tokens.Number, tokens.Expression),
-      choice(tokens.Number, tokens.Expression)
+      tokens.Expression,
+      tokens.Expression
     )
-    
+
     tokens.Div ::= fields(
-      choice(tokens.Number, tokens.Expression),
-      choice(tokens.Number, tokens.Expression)
+      tokens.Expression,
+      tokens.Expression
     )
 
     tokens.Expression ::= choice(
+      tokens.Number,
       tokens.Add,
       tokens.Sub,
       tokens.Mul,
@@ -78,4 +89,4 @@ val wellformed: Wellformed =
 
 object read:
   def fromSourceRange(sourceRange: SourceRange): Node.Top =
-    CalcReader(sourceRange)
\ No newline at end of file
+    CalcReader(sourceRange)

From 5f34b74242ab29f2a85f2d8de3b01252fecdf0c1 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Sat, 22 Mar 2025 00:02:11 -0400
Subject: [PATCH 08/11] cleaning up final pass

---
 calc/CalcEvaluator.scala | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/calc/CalcEvaluator.scala b/calc/CalcEvaluator.scala
index 04c0361..3404262 100644
--- a/calc/CalcEvaluator.scala
+++ b/calc/CalcEvaluator.scala
@@ -118,7 +118,5 @@ object CalcEvaluator extends PassSeq:
               ~ eof
         ).rewrite: (number) =>
           splice(
-            Number(
-              number.unparent().sourceRange.decodeString()
-            )
+            number.unparent()
           )

From b14b9eb1b7d0acd057076e6b70b14e51a3401fd3 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 9 Apr 2025 08:46:37 -0400
Subject: [PATCH 09/11] nitpick fix w/ building off prevWellformed

---
 calc/CalcEvaluator.scala | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/calc/CalcEvaluator.scala b/calc/CalcEvaluator.scala
index 3404262..5b1fca9 100644
--- a/calc/CalcEvaluator.scala
+++ b/calc/CalcEvaluator.scala
@@ -29,7 +29,8 @@ object CalcEvaluator extends PassSeq:
   def inputWellformed: Wellformed = distcompiler.calc.wellformed
 
   private val simplifyPass = passDef:
-    wellformed := inputWellformed
+    wellformed := inputWellformed.makeDerived:
+      Node.Top ::=! Expression
 
     pass(once = false, strategy = pass.bottomUp)
       .rules:
@@ -107,8 +108,8 @@ object CalcEvaluator extends PassSeq:
           )
 
   private val removeLayerPass = passDef:
-    wellformed := inputWellformed.makeDerived:
-      Node.Top ::=! fields(Number)
+    wellformed := prevWellformed.makeDerived:
+      Node.Top ::=! Number
 
     pass(once = true, strategy = pass.topDown)
       .rules:

From 64d558c34ebf802fa593c2b3ef4215ea74df9901 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 9 Apr 2025 08:47:02 -0400
Subject: [PATCH 10/11] added a readme

---
 calc/README.md        |  79 ++++++++++++++++++++++++++++++++++++++++++
 calc/img/example1.jpg | Bin 0 -> 58121 bytes
 calc/img/example2.jpg | Bin 0 -> 90964 bytes
 3 files changed, 79 insertions(+)
 create mode 100644 calc/README.md
 create mode 100644 calc/img/example1.jpg
 create mode 100644 calc/img/example2.jpg

diff --git a/calc/README.md b/calc/README.md
new file mode 100644
index 0000000..5a86316
--- /dev/null
+++ b/calc/README.md
@@ -0,0 +1,79 @@
+# ```calc/```
+
+## Overview
+A parser and evaluator for arithmetic expressions given in string inputs; supporting addition, subtraction, multiplication, and division operations.
+
+
+## Motivation
+The calculator exists as a practical example demonstrating how DCal can be leveraged to parse languages and manipulate ASTs, with many of DCal's core features such as ```Wellformed```, ```PassSeq```, and ```SeqPattern``` being heavily used.
+
+
+## Components
+
+### 1. ```package.scala```
+Defines all of the ```Token``` types that are used and provides a wellformed definition representing how the AST should be structured once fully built.
+
+
+### 2. ```CalcReader.scala```
+```CalcReader``` is the lexer that converts input strings into tokens. 
+
+It contains a wellformed definition of the initial token types with ```Number``` tokens that're wrapped around ```Expression``` and ```Op``` tokens for operations.
+
+The ```rules``` method uses byte-level pattern matching to create tokens for numbers and operators and skip anything else.
+
+
+### 3. ```CalcParser.scala```
+```CalcParser``` is the parser, transforming the flat list of tokens into a structured AST.
+
+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
+
+```
+Expression(
+  Operation(
+    Expression,
+    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. 
+
+
+### 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```.
+
+
+## Usage
+To learn how to use the calculator, ```CalcReader.test.scala``` contains methods (```parse```, ```read```, ```evaluate```) that execute the different components of the calculator.
+
+
+## Example
+The following images demonstrates the state of the AST after each pass with the input "5 + 3 * 4". 
+
+![example1](img/example1.jpg)
+![exampel2](img/example2.jpg)
diff --git a/calc/img/example1.jpg b/calc/img/example1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6ba2279af6b1268115d18935a02a91f97514d5dd
GIT binary patch
literal 58121
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
S*B)ODatPmMxL5ts^8WxU;TRAA

literal 0
HcmV?d00001

diff --git a/calc/img/example2.jpg b/calc/img/example2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ac2ef1b675a6b25cbaa305699dbb255828dffa70
GIT binary patch
literal 90964
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
aMQ?6Au-f=<Xpa2f^clY&4bXi0@c#hjHw$tA

literal 0
HcmV?d00001


From 01b486f50b8d669073f1584fe70b561d1fc635a8 Mon Sep 17 00:00:00 2001
From: navidaminnn <mynameisnavid@gmail.com>
Date: Wed, 9 Apr 2025 08:59:39 -0400
Subject: [PATCH 11/11] mentioned tracer

---
 calc/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/calc/README.md b/calc/README.md
index 5a86316..c87b7d1 100644
--- a/calc/README.md
+++ b/calc/README.md
@@ -73,7 +73,7 @@ To learn how to use the calculator, ```CalcReader.test.scala``` contains methods
 
 
 ## Example
-The following images demonstrates the state of the AST after each pass with the input "5 + 3 * 4". 
+The following images demonstrates the state of the AST after each pass with the input "5 + 3 * 4". Viewing the state of the AST after each pass can also be done by running calculator test cases with the tracer enabled. 
 
 ![example1](img/example1.jpg)
 ![exampel2](img/example2.jpg)