add Logic Types

Author: willow-ahrens

src/finchlite/finch_logic/__init__.py

@@ -20,15 +20,19 @@
     TableValueFType,
     Value,
 )
+from .stages import LogicEvaluator, LogicLowerer, LogicTransform
 
 __all__ = [
     "Aggregate",
     "Alias",
     "Field",
     "FinchLogicInterpreter",
     "Literal",
+    "LogicEvaluator",
     "LogicExpression",
+    "LogicLowerer",
     "LogicNode",
+    "LogicTransform",
     "LogicTree",
     "MapJoin",
     "Plan",

src/finchlite/finch_logic/interpreter.py

@@ -19,15 +19,18 @@
     TableValue,
     Value,
 )
+from .stages import LogicEvaluator
 
 
-class FinchLogicInterpreter:
+class FinchLogicInterpreter(LogicEvaluator):
     def __init__(self, *, make_tensor=np.full, verbose=False):
         self.verbose = verbose
         self.bindings = {}
         self.make_tensor = make_tensor  # Added make_tensor argument
 
-    def __call__(self, node):
+    def __call__(self, node, bindings=None):
+        if bindings is not None:
+            self.bindings = bindings.copy()
         # Example implementation for evaluating an expression
         if self.verbose:
             print(f"Evaluating: {node}")

src/finchlite/finch_logic/stages.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+from finchlite.algebra.tensor import TensorFType
+
+from .. import finch_notation as ntn
+from ..symbolic import Stage
+from . import nodes as lgc
+
+
+class LogicEvaluator(Stage):
+    @abstractmethod
+    def __call__(self, term: lgc.LogicNode, bindings: dict[lgc.Alias, lgc.TableValue]|None=None) -> lgc.TableValue | tuple[lgc.TableValue]:
+        """
+        Evaluate the given logic.
+        """
+
+
+class LogicLowerer(ABC):
+    @abstractmethod
+    def __call__(
+        self, term: lgc.LogicNode, bindings: dict[lgc.Alias, TensorFType]
+    ) -> tuple[ntn.Module, dict[lgc.Alias, TensorFType]]:
+        """
+        Generate Finch Notation from the given logic and input types,
+        types for all aliases.
+        """
+
+
+class LogicTransform(ABC):
+    @abstractmethod
+    def __call__(self, term: lgc.LogicNode, bindings: dict[lgc.Alias, TensorFType]) -> tuple[lgc.LogicNode, dict[lgc.Alias, TensorFType]]:
+        """
+        Transform the given logic term into another logic term.
+        """