First take at partial term reconstruction

Author: SaltyPeppermint

src/python/data.rs src/python/data/mod.rssrc/python/data.rs renamed to src/python/data/mod.rs

@@ -0,0 +1,128 @@
+use pyo3::prelude::*;
+use pyo3_stub_gen::derive::{gen_stub_pyclass, gen_stub_pymethods};
+
+use serde::Serialize;
+
+use crate::trs::SymbolInfo;
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub enum NodeOrPlaceHolder {
+    Node(Node),
+    Placeholder {
+        depth: usize,
+        dfs_order: usize,
+        nth_child: usize,
+    },
+}
+
+impl NodeOrPlaceHolder {
+    #[must_use]
+    pub fn id(&self) -> Option<usize> {
+        match self {
+            NodeOrPlaceHolder::Node(node) => Some(node.id()),
+            NodeOrPlaceHolder::Placeholder { .. } => None,
+        }
+    }
+
+    #[must_use]
+    pub fn value(&self) -> Option<String> {
+        match self {
+            NodeOrPlaceHolder::Node(node) => node.symbol_info.value(),
+            NodeOrPlaceHolder::Placeholder { .. } => None,
+        }
+    }
+
+    #[must_use]
+    pub fn name(&self) -> String {
+        if let NodeOrPlaceHolder::Node(n) = self {
+            match n.symbol_info.symbol_type() {
+                crate::trs::SymbolType::Constant(_) => "[constant]".to_owned(),
+                crate::trs::SymbolType::Variable(_) => "[variable]".to_owned(),
+                crate::trs::SymbolType::MetaSymbol | crate::trs::SymbolType::Operator => {
+                    n.raw_name.clone()
+                }
+            }
+        } else {
+            "[PLACEHOLDER]".to_owned()
+        }
+    }
+
+    #[must_use]
+    pub fn depth(&self) -> usize {
+        match self {
+            NodeOrPlaceHolder::Node(node) => node.depth,
+            NodeOrPlaceHolder::Placeholder { depth, .. } => *depth,
+        }
+    }
+}
+
+#[gen_stub_pyclass]
+#[pyclass(frozen, module = "eggshell")]
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct Node {
+    #[pyo3(get)]
+    raw_name: String,
+    #[pyo3(get)]
+    arity: usize,
+    #[pyo3(get)]
+    nth_child: usize,
+    #[pyo3(get)]
+    dfs_order: usize,
+    #[pyo3(get)]
+    depth: usize,
+    symbol_info: SymbolInfo,
+}
+
+impl Node {
+    #[must_use]
+    pub fn new(
+        raw_name: String,
+        arity: usize,
+        nth_child: usize,
+        dfs_order: usize,
+        depth: usize,
+        symbol_info: SymbolInfo,
+    ) -> Self {
+        Self {
+            raw_name,
+            arity,
+            nth_child,
+            dfs_order,
+            depth,
+            symbol_info,
+        }
+    }
+
+    #[must_use]
+    pub fn symbol_info(&self) -> &SymbolInfo {
+        &self.symbol_info
+    }
+}
+
+#[gen_stub_pymethods]
+#[pymethods]
+impl Node {
+    #[must_use]
+    #[getter]
+    pub fn id(&self) -> usize {
+        self.symbol_info.id()
+    }
+
+    #[must_use]
+    #[getter]
+    pub fn value(&self) -> Option<String> {
+        self.symbol_info.value()
+    }
+
+    #[must_use]
+    #[getter]
+    pub fn name(&self) -> String {
+        match self.symbol_info.symbol_type() {
+            crate::trs::SymbolType::Constant(_) => "[constant]".to_owned(),
+            crate::trs::SymbolType::Variable(_) => "[variable]".to_owned(),
+            crate::trs::SymbolType::MetaSymbol | crate::trs::SymbolType::Operator => {
+                self.raw_name.clone()
+            }
+        }
+    }
+}

src/python/data/nodes.rs

@@ -9,6 +9,7 @@ macro_rules! monomorphize {
 
         use $crate::eqsat::conf::EqsatConf;
         use $crate::eqsat::{Eqsat, StartMaterial};
+        use $crate::python::data;
         use $crate::python::data::TreeData;
         use $crate::python::err::EggshellError;
         use $crate::trs::{MetaInfo, TermRewriteSystem};
@@ -87,6 +88,16 @@ macro_rules! monomorphize {
             }
         }
 
+        #[gen_stub_pyfunction(module = $module_name)]
+        #[pyfunction]
+        #[expect(clippy::missing_errors_doc)]
+        pub fn partial_parse(token_list: Vec<String>) -> PyResult<TreeData> {
+            let r = data::partial_parse::<L>(token_list)
+                .and_then(|partial: Vec<Option<L>>| TreeData::try_from(partial))
+                .map_err(|e| EggshellError::<L>::from(e))?;
+            Ok(r)
+        }
+
         #[gen_stub_pyfunction(module = $module_name)]
         #[pyfunction]
         #[must_use]

src/python/monomorphize.rs

@@ -116,6 +116,8 @@ impl<L: Language + MetaInfo> MetaInfo for SketchLang<L> {
     }
 
     const NUM_SYMBOLS: usize = L::NUM_SYMBOLS + Self::COUNT;
+
+    const MAX_ARITY: usize = { if L::MAX_ARITY > 2 { L::MAX_ARITY } else { 2 } };
 }
 
 impl<L: Language + Display> Display for SketchLang<L> {

src/sketch/full_sketch.rs

@@ -104,6 +104,8 @@ impl<L: Language + MetaInfo> MetaInfo for PartialSketchLang<L> {
     }
 
     const NUM_SYMBOLS: usize = SketchLang::<L>::NUM_SYMBOLS + Self::COUNT;
+
+    const MAX_ARITY: usize = SketchLang::<L>::MAX_ARITY;
 }
 
 impl<L: Language + Display> Display for PartialSketchLang<L> {

src/sketch/partial_sketch.rs

@@ -58,6 +58,8 @@ impl MetaInfo for Math {
             "d", "i", "+", "-", "*", "/", "pow", "ln", "sqrt", "sin", "cos",
         ]
     }
+
+    const MAX_ARITY: usize = 2;
 }
 
 // impl Typeable for Math {

src/trs/arithmetic/mod.rs

@@ -65,6 +65,8 @@ impl MetaInfo for HalideLang {
             "&&",
         ]
     }
+
+    const MAX_ARITY: usize = 2;
 }
 
 // impl Typeable for HalideLang {

src/trs/halide/mod.rs

@@ -90,6 +90,7 @@ pub trait MetaInfo: Display + Language + EnumCount {
     fn operators() -> Vec<&'static str>;
 
     const NUM_SYMBOLS: usize = Self::COUNT;
+    const MAX_ARITY: usize;
 }
 
 #[derive(Debug, Error)]

src/trs/mod.rs

@@ -91,6 +91,8 @@ impl MetaInfo for RiseLang {
             "snd",
         ]
     }
+
+    const MAX_ARITY: usize = 3;
 }
 
 #[derive(Default, Debug, Clone, Copy, Serialize)]

src/trs/rise/mod.rs

@@ -36,6 +36,8 @@ impl MetaInfo for SimpleLang {
     fn operators() -> Vec<&'static str> {
         vec!["+", "*"]
     }
+
+    const MAX_ARITY: usize = 2;
 }
 
 // impl Typeable for SimpleLang {