Memory management optimizations

examples/src/main/scala-3/foresight/eqsat/examples/arithWithLang/ApplierOps.scala

@@ -32,7 +32,7 @@ object ApplierOps {
 
           def subst(tree: ArithExpr): ArithExpr = {
             tree match {
-              case Var(slot) if slot == m(from) => L.fromTree[EClassCall](m(to.variable))
+              case Var(slot) if slot == m(from) => L.fromTree(m(to.variable))
               case Var(slot) => Var(slot)
               case Lam(param, body) => Lam(param, subst(body))
               case App(fun, arg) => App(subst(fun), subst(arg))
@@ -46,7 +46,7 @@ object ApplierOps {
           }
 
           val substituted = subst(extractedExpr)
-          val newMatch = m.copy(varMapping = m.varMapping + (destination.variable -> L.toTree[EClassCall](substituted)))
+          val newMatch = m.bind(destination.variable, L.toCallTree(substituted))
           applier.apply(newMatch, egraph, builder)
         }
       }

examples/src/main/scala-3/foresight/eqsat/examples/arithWithLang/Rules.scala

@@ -64,7 +64,7 @@ final case class Rules()(using L: Language[ArithExpr]) {
           result.toSeq.map { value =>
             // If a constant value is found, create a new Number node and bind it to the variable, overwriting the
             // original binding.
-            subst.bind(x.variable, L.toTree(Number(value)))
+            subst.bind(x.variable, L.toCallTree(Number(value)))
           }
       }),
       L.toApplier(x)

examples/src/main/scala-3/foresight/eqsat/examples/mm/Rules.scala

@@ -3,7 +3,7 @@ package foresight.eqsat.examples.mm
 import foresight.eqsat.lang.{Language, LanguageOp}
 import foresight.eqsat.readonly.EGraph
 import foresight.eqsat.rewriting.Rule
-import foresight.eqsat.rewriting.patterns.PatternMatch
+import foresight.eqsat.rewriting.patterns.AbstractPatternMatch
 
 import scala.language.implicitConversions
 
@@ -13,17 +13,17 @@ import scala.language.implicitConversions
 final case class Rules()(using L: Language[LinalgExpr]) {
   type Op = LanguageOp[LinalgExpr]
   type LinalgEGraph = EGraph[LinalgIR]
-  type LinalgRule = Rule[LinalgIR, PatternMatch[LinalgIR], LinalgEGraph]
+  type LinalgRule = Rule[LinalgIR, AbstractPatternMatch[LinalgIR], LinalgEGraph]
 
-  import L.rule
+  import L.borrowingRule
 
   val matMulAssociativity1: LinalgRule =
-    rule("mul-associativity1") { (x, y, z) =>
+    borrowingRule("mul-associativity1") { (x, y, z) =>
       ((x * y) * z) -> (x * (y * z))
     }
 
   val matMulAssociativity2: LinalgRule =
-    rule("mul-associativity2") { (x, y, z) =>
+    borrowingRule("mul-associativity2") { (x, y, z) =>
       (x * (y * z)) -> ((x * y) * z)
     }
 

examples/src/main/scala/foresight/eqsat/examples/arith/ApplierOps.scala

@@ -27,16 +27,16 @@ object ApplierOps {
         override def apply(m: PatternMatch[ArithIR], egraph: EGraphWithMetadata[ArithIR, EGraphT], builder: CommandScheduleBuilder[ArithIR]): Unit = {
           val extracted = ExtractionAnalysis.smallest[ArithIR].extractor[EGraphT](m(source), egraph)
 
-          def subst(tree: Tree[ArithIR]): MixedTree[ArithIR, EClassCall] = {
+          def subst(tree: Tree[ArithIR]): CallTree[ArithIR] = {
             tree match {
               case Tree(Var, Seq(), Seq(use), Seq()) if use == m(from) => m(to)
               case Tree(nodeType, defs, uses, args) =>
-                MixedTree.Node(nodeType, defs, uses, args.map(subst))
+                CallTree.Node(nodeType, defs, uses, args.map(subst))
             }
           }
 
           val substituted = subst(extracted)
-          val newMatch = m.copy(varMapping = m.varMapping + (destination -> substituted))
+          val newMatch = m.bind(destination, substituted)
           applier.apply(newMatch, egraph, builder)
         }
       }

examples/src/main/scala/foresight/eqsat/examples/arith/Rules.scala

@@ -4,7 +4,7 @@ import foresight.eqsat.examples.arith.ApplierOps._
 import foresight.eqsat.readonly.{EGraph, EGraphWithMetadata}
 import foresight.eqsat.rewriting.Rule
 import foresight.eqsat.rewriting.patterns.{Pattern, PatternMatch}
-import foresight.eqsat.{MixedTree, Slot}
+import foresight.eqsat.{CallTree, MixedTree, Slot}
 
 /**
  * This object contains a collection of rules for rewriting arithmetic expressions.
@@ -63,7 +63,7 @@ object Rules {
           result.toSeq.map { value =>
             // If a constant value is found, create a new Number node and bind it to the variable, overwriting the
             // original binding.
-            subst.bind(x, Number(value))
+            subst.bind(x, CallTree.from(Number(value)))
           }
       }),
       MixedTree.Atom[ArithIR, Pattern.Var](x).toApplier

examples/src/main/scala/foresight/eqsat/examples/liar/ApplierOps.scala

@@ -28,23 +28,23 @@ object ApplierOps {
         override def apply(m: PatternMatch[ArrayIR], egraph: EGraphWithMetadata[ArrayIR, EGraphT], builder: CommandScheduleBuilder[ArrayIR]): Unit = {
           val extracted = ExtractionAnalysis.smallest[ArrayIR].extractor[EGraphT](m(source), egraph)
 
-          def typeOf(tree: MixedTree[ArrayIR, EClassCall]): MixedTree[Type, EClassCall] = {
-            TypeInferenceAnalysis.get(egraph)(tree, egraph)
+          def typeOf(tree: CallTree[ArrayIR]): CallTree[Type] = {
+            CallTree.from(TypeInferenceAnalysis.get(egraph)(tree, egraph))
           }
 
-          def subst(tree: Tree[ArrayIR]): MixedTree[ArrayIR, EClassCall] = {
+          def subst(tree: Tree[ArrayIR]): CallTree[ArrayIR] = {
             tree match {
               case Tree(Var, Seq(), Seq(use), Seq(fromType))
-                if use == m(from) && typeOf(m(to)) == MixedTree.fromTree(fromType) =>
+                if use == m(from) && typeOf(m(to)) == CallTree.from(fromType) =>
 
                 m(to)
               case Tree(nodeType, defs, uses, args) =>
-                MixedTree.Node(nodeType, defs, uses, args.map(subst))
+                CallTree.Node(nodeType, defs, uses, args.map(subst))
             }
           }
 
           val substituted = subst(extracted)
-          val newMatch = m.copy(varMapping = m.varMapping + (destination -> substituted))
+          val newMatch = m.bind(destination, substituted)
           applier.apply(newMatch, egraph, builder)
         }
       }
@@ -66,7 +66,7 @@ object ApplierOps {
           val tree = applier.instantiate(m)
           val realTree = tree.mapAtoms(_.asInstanceOf[EClassCall])
           inferType(realTree, egraph)
-          val c = builder.addSimplifiedReal(realTree, egraph)
+          val c = builder.addSimplifiedReal(CallTree.from(realTree), egraph)
           builder.unionSimplified(EClassSymbol.real(m.root), c, egraph)
         }
       }

examples/src/main/scala/foresight/eqsat/examples/liar/SearcherOps.scala

@@ -4,7 +4,7 @@ import foresight.eqsat.examples.liar.TypeRequirements.RequirementsSearcherContin
 import foresight.eqsat.parallel.ParallelMap
 import foresight.eqsat.rewriting.patterns.{CompiledPattern, Pattern, PatternMatch}
 import foresight.eqsat.rewriting.{Applier, ReversibleSearcher, Searcher}
-import foresight.eqsat.MixedTree
+import foresight.eqsat.{CallTree, EClassCall, MixedTree}
 import foresight.eqsat.immutable.{EGraph, EGraphLike, EGraphWithMetadata}
 
 object SearcherOps {
@@ -23,8 +23,8 @@ object SearcherOps {
       searcher.map((m, egraph) => {
         val newVarMapping = m.varMapping ++ types.map {
           case (value, t) =>
-            val (call, newEGraph) = egraph.add(m(value))
-            t -> TypeInferenceAnalysis.get(newEGraph)(call, newEGraph)
+            val (call, newEGraph) = egraph.add(m(value).toMixedTree)
+            t -> CallTree.from(TypeInferenceAnalysis.get(newEGraph)(call, newEGraph))
         }
         PatternMatch(m.root, newVarMapping, m.slotMapping)
       })
@@ -53,8 +53,8 @@ object SearcherOps {
       searcher.filter((m, egraph) => {
         values.forall(v => {
           m(v) match {
-            case MixedTree.Atom(c) => egraph.nodes(c).head.nodeType.isInstanceOf[Value]
-            case MixedTree.Node(nodeType, _, _, _) => nodeType.isInstanceOf[Value]
+            case c: EClassCall => egraph.nodes(c).head.nodeType.isInstanceOf[Value]
+            case CallTree.Node(nodeType, _, _, _) => nodeType.isInstanceOf[Value]
           }
         })
       })
@@ -69,8 +69,8 @@ object SearcherOps {
     def requireNonFunctionType(t: Pattern.Var): Searcher[ArrayIR, PatternMatch[ArrayIR], EGraphT] = {
       searcher.filter((m, egraph) => {
         m(t) match {
-          case MixedTree.Atom(c) => egraph.nodes(c).head.nodeType != FunctionType
-          case MixedTree.Node(nodeType, _, _, _) => nodeType != FunctionType
+          case c: EClassCall => egraph.nodes(c).head.nodeType != FunctionType
+          case CallTree.Node(nodeType, _, _, _) => nodeType != FunctionType
         }
       })
     }
@@ -83,8 +83,8 @@ object SearcherOps {
     def requireInt32Type(t: Pattern.Var): Searcher[ArrayIR, PatternMatch[ArrayIR], EGraphT] = {
       searcher.filter((m, egraph) => {
         m(t) match {
-          case MixedTree.Atom(c) => egraph.nodes(c).head.nodeType == Int32Type
-          case MixedTree.Node(nodeType, _, _, _) => nodeType == Int32Type
+          case c: EClassCall => egraph.nodes(c).head.nodeType == Int32Type
+          case CallTree.Node(nodeType, _, _, _) => nodeType == Int32Type
         }
       })
     }
@@ -97,8 +97,8 @@ object SearcherOps {
     def requireDoubleType(t: Pattern.Var): Searcher[ArrayIR, PatternMatch[ArrayIR], EGraphT] = {
       searcher.filter((m, egraph) => {
         m(t) match {
-          case MixedTree.Atom(c) => egraph.nodes(c).head.nodeType == DoubleType
-          case MixedTree.Node(nodeType, _, _, _) => nodeType == DoubleType
+          case c: EClassCall => egraph.nodes(c).head.nodeType == DoubleType
+          case CallTree.Node(nodeType, _, _, _) => nodeType == DoubleType
         }
       })
     }

examples/src/main/scala/foresight/eqsat/examples/sdql/ApplierOps.scala

@@ -27,16 +27,16 @@ object ApplierOps {
         override def apply(m: PatternMatch[SdqlIR], egraph: EGraphWithMetadata[SdqlIR, EGraphT], builder: CommandScheduleBuilder[SdqlIR]): Unit = {
           val extracted = ExtractionAnalysis.smallest[SdqlIR].extractor[EGraphT](m(source), egraph)
 
-          def subst(tree: Tree[SdqlIR]): MixedTree[SdqlIR, EClassCall] = {
+          def subst(tree: Tree[SdqlIR]): CallTree[SdqlIR] = {
             tree match {
               case Tree(Var, Seq(), Seq(use), Seq()) if use == m(from) => m(to)
               case Tree(nodeType, defs, uses, args) =>
-                MixedTree.Node(nodeType, defs, uses, args.map(subst))
+                CallTree.Node(nodeType, defs, uses, args.map(subst))
             }
           }
 
           val substituted = subst(extracted)
-          val newMatch = m.copy(varMapping = m.varMapping + (destination -> substituted))
+          val newMatch = m.bind(destination, substituted)
           applier.apply(newMatch, egraph, builder)
         }
       }

examples/src/test/scala-3/foresight/eqsat/examples/mm/MMTest.scala

@@ -1,8 +1,7 @@
 package foresight.eqsat.examples.mm
 
-import foresight.eqsat.examples.mm.{Fact, LinalgExpr, LinalgIR, Mat, Mul, Rules, *}
 import foresight.eqsat.lang._
-import foresight.eqsat.saturation.{MaximalRuleApplication, MaximalRuleApplicationWithCaching, Strategy}
+import foresight.eqsat.saturation.{MaximalRuleApplication, Strategy}
 import foresight.eqsat.EClassCall
 import foresight.eqsat.immutable.EGraph
 import foresight.eqsat.mutable