Add simpler error handling

Author: saulshanabrook

Cargo.lock

@@ -14,3 +14,7 @@ egg-smol = { git = "https://github.com/mwillsey/egg-smol", rev = "94c173b9d6152c
 
 [package.metadata.maturin]
 name = "egg_smol.bindings"
+
+# Patch egg-smol to use local version
+[patch.crates-io]
+egg-smol = { path = "../egg-smol" }

Cargo.toml

@@ -0,0 +1,39 @@
+use pyo3::prelude::*;
+
+// Create exceptions with class instead of create_exception! macro
+// https://github.com/PyO3/pyo3/issues/295#issuecomment-852358088
+#[pyclass(extends=pyo3::exceptions::PyException)]
+pub struct EggSmolError {
+    #[pyo3(get)]
+    context: String,
+}
+
+#[pymethods]
+impl EggSmolError {
+    #[new]
+    fn new(context: String) -> Self {
+        EggSmolError { context }
+    }
+}
+
+// Wrap the egg_smol::Error so we can automatically convert from it to the PyErr
+// and so return it from each function automatically
+// https://pyo3.rs/latest/function/error_handling.html#foreign-rust-error-types
+pub struct WrappedError(egg_smol::Error);
+
+// Convert from the WrappedError to the PyErr by creating a new Python error
+impl From<WrappedError> for PyErr {
+    fn from(error: WrappedError) -> Self {
+        PyErr::new::<EggSmolError, _>(error.0.to_string())
+    }
+}
+
+// Convert from an egg_smol::Error to a WrappedError
+impl From<egg_smol::Error> for WrappedError {
+    fn from(other: egg_smol::Error) -> Self {
+        Self(other)
+    }
+}
+
+// Use similar to PyResult, wraps a result type and can be converted to PyResult
+pub type EggResult<T> = Result<T, WrappedError>;

src/error.rs

@@ -1,3 +1,5 @@
+mod error;
+use error::*;
 use pyo3::prelude::*;
 
 /// EGraph()
@@ -9,22 +11,6 @@ struct EGraph {
     egraph: egg_smol::EGraph,
 }
 
-// Create exceptions with class instead of create_exception! macro
-// https://github.com/PyO3/pyo3/issues/295#issuecomment-852358088
-#[pyclass(extends=pyo3::exceptions::PyException)]
-pub struct EggSmolError {
-    #[pyo3(get)]
-    context: String,
-}
-
-#[pymethods]
-impl EggSmolError {
-    #[new]
-    fn new(context: String) -> Self {
-        EggSmolError { context }
-    }
-}
-
 // Convert a Python Variant object into a rust variable, by getting the attributes
 fn get_variant(obj: &PyAny) -> PyResult<egg_smol::ast::Variant> {
     // TODO: Is there a way to do this more automatically?
@@ -56,22 +42,24 @@ impl EGraph {
     /// --
     ///
     /// Declare a new sort with the given name.
-    fn declare_sort(&mut self, name: &str) -> PyResult<()> {
+    fn declare_sort(&mut self, name: &str) -> EggResult<()> {
         // TODO: Should the name be a symbol? If so, how should we expose that
         // to Python?
-        self.egraph
-            .declare_sort(name)
-            .map_err(|e| PyErr::new::<EggSmolError, _>(e.to_string()))
+        self.egraph.declare_sort(name)?;
+        Ok({})
     }
 
+    /// declare_constructor($self, variant, sort)
+    /// --
+    ///
+    /// Declare a new datatype constructor.
     fn declare_constructor(
         &mut self,
         #[pyo3(from_py_with = "get_variant")] variant: egg_smol::ast::Variant,
         sort: &str,
-    ) -> PyResult<()> {
-        self.egraph
-            .declare_constructor(variant, sort)
-            .map_err(|e| PyErr::new::<EggSmolError, _>(e.to_string()))
+    ) -> EggResult<()> {
+        self.egraph.declare_constructor(variant, sort)?;
+        Ok({})
     }
 
     /// parse_and_run_program($self, input)
@@ -80,10 +68,9 @@ impl EGraph {
     /// Parse the input string as a program and run it on the EGraph.
     /// Returns a list of strings representing the output.
     /// An EggSmolError is raised if there is problem parsing or executing.
-    fn parse_and_run_program(&mut self, input: &str) -> PyResult<Vec<String>> {
-        self.egraph
-            .parse_and_run_program(input)
-            .map_err(|e| PyErr::new::<EggSmolError, _>(e.to_string()))
+    fn parse_and_run_program(&mut self, input: &str) -> EggResult<Vec<String>> {
+        let res = self.egraph.parse_and_run_program(input)?;
+        Ok(res)
     }
 }