simplify errors

Cargo.toml

@@ -9,7 +9,7 @@ authors = ["Tim Beurskens <timbeurskens.97@gmail.com>"]
 [package]
 name = "rsbdd"
 description = "A BDD-based SAT solver"
-version = "0.12.0"
+version = "0.13.0"
 edition.workspace = true
 authors.workspace = true
 

max_clique_gen/src/main.rs

@@ -156,7 +156,7 @@ fn main() -> Result<()> {
     }
 
     // flush the writer before dropping it
-    writer.flush().expect("Could not flush write buffer");
+    writer.flush()?;
 
     Ok(())
 }

src/bdd.rs

@@ -10,13 +10,15 @@ use crate::{BDDSymbol, NamedSymbol, TruthTableEntry};
 
 #[macro_export]
 macro_rules! bdd {
-    ($($expr:tt)+) => {{
-        let input = stringify!($($expr)+);
-        let mut input_reader = std::io::BufReader::new(input.as_bytes());
-        let parsed_formula = rsbdd::parser::ParsedFormula::new(&mut input_reader, None).expect("could not parse expression");
-
-        parsed_formula.eval()
-    }};
+    ($($expr:tt)+) => {
+        (|| -> anyhow::Result<_> {
+            let input = stringify!($($expr)+);
+            let mut input_reader = std::io::BufReader::new(input.as_bytes());
+            let parsed_formula = rsbdd::parser::ParsedFormula::new(&mut input_reader, None)?;
+
+            Ok(parsed_formula.eval())
+        })()
+    };
 }
 
 #[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]

src/bin/rsbdd.rs

@@ -74,7 +74,7 @@ struct Args {
     export_ordering: bool,
 }
 
-fn main() {
+fn main() -> anyhow::Result<()> {
     let wild_args = wild::args_os();
     let args_in =
         argfile::expand_args_from(wild_args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
@@ -88,34 +88,30 @@ fn main() {
     let mut reader = if let Some(inline_str) = &inline_eval {
         Box::new(BufReader::new(inline_str.as_bytes())) as Box<dyn BufRead>
     } else if let Some(some_input_filename) = input_filename {
-        let file = File::open(some_input_filename).expect("Could not open input file");
+        let file = File::open(some_input_filename)?;
         Box::new(BufReader::new(file)) as Box<dyn BufRead>
     } else {
         Box::new(BufReader::new(io::stdin())) as Box<dyn BufRead>
     };
 
     let pre_variable_ordering = if let Some(ord_filename) = args.ordering {
-        let file = File::open(ord_filename).expect("Could not open variable ordering file");
+        let file = File::open(ord_filename)?;
         let mut contents = Box::new(BufReader::new(file)) as Box<dyn BufRead>;
-        let tokens = SymbolicBDD::tokenize(&mut contents, None)
-            .expect("Could not extract tokens from variable ordering");
+        let tokens = SymbolicBDD::tokenize(&mut contents, None)?;
         let vars = ParsedFormula::extract_vars(&tokens);
         Some(vars)
     } else {
         None
     };
 
-    let input_parsed =
-        ParsedFormula::new(&mut reader, pre_variable_ordering).expect("Could not parse input file");
+    let input_parsed = ParsedFormula::new(&mut reader, pre_variable_ordering)?;
 
     if let Some(parsetree_filename) = args.parsetree {
-        let mut f = File::create(parsetree_filename).expect("Could not create parsetree dot file");
+        let mut f = File::create(parsetree_filename)?;
 
         let graph = SymbolicParseTree::new(&input_parsed.bdd);
 
-        graph
-            .render_dot(&mut f)
-            .expect("Could not write parsetree to dot file");
+        graph.render_dot(&mut f)?;
     }
 
     let mut result: Rc<BDD<NamedSymbol>> = Rc::default();
@@ -143,7 +139,7 @@ fn main() {
         print_performance_results(&exec_times);
 
         if args.plot {
-            plot_performance_results(&exec_times);
+            plot_performance_results(&exec_times)?;
         }
     }
 
@@ -209,14 +205,14 @@ fn main() {
     }
 
     if let Some(dot_filename) = args.dot {
-        let mut f = File::create(dot_filename).expect("Could not create dot file");
+        let mut f = File::create(dot_filename)?;
 
         let graph = BDDGraph::new(&result, args.filter);
 
-        graph
-            .render_dot(&mut f)
-            .expect("Could not write BDD to dot file");
+        graph.render_dot(&mut f)?
     }
+
+    Ok(())
 }
 
 fn print_sized_line<B, C, D>(labels: &Vec<D>, widths: &B, result: &BDD<C>)
@@ -294,15 +290,14 @@ fn print_performance_results(results: &[Duration]) {
 }
 
 // invoke gnuplot to show the run-time distribution plot
-fn plot_performance_results(results: &[Duration]) {
+fn plot_performance_results(results: &[Duration]) -> anyhow::Result<()> {
     let (_, _, _, mean, stddev) = stats(results);
 
     let mut gnuplot_cmd = Command::new("gnuplot")
         .arg("-p") // persistent mode
         .arg("-") // piped mode
         .stdin(Stdio::piped())
-        .spawn()
-        .expect("Could not spawn gnuplot");
+        .spawn()?;
 
     let stdin = gnuplot_cmd.stdin.as_mut().unwrap();
     write_gnuplot_normal_distribution(
@@ -311,12 +306,11 @@ fn plot_performance_results(results: &[Duration]) {
         mean + (stddev * 2.0),
         mean,
         stddev,
-    )
-    .expect("Could not write to gnuplot command");
+    )?;
+
+    gnuplot_cmd.wait()?;
 
-    gnuplot_cmd
-        .wait()
-        .expect("Could not wait for gnuplot to finish");
+    Ok(())
 }
 
 // print all variables which can take a 'true' value in the bdd

sudoku_gen/src/main.rs

@@ -133,7 +133,7 @@ fn main() -> io::Result<()> {
 
     writeln!(writer, "true")?;
 
-    writer.flush().expect("Could not flush write buffer");
+    writer.flush()?;
 
     Ok(())
 }

tests/bdd_test.rs

@@ -640,9 +640,9 @@ fn test_queens() {
 
 #[test]
 fn test_basic_syntax_1() {
-    let e1 = bdd!(a | -a);
-    let e2 = bdd!(a | b | c);
-    let e3 = bdd!(false);
+    let e1 = bdd!(a | -a).unwrap();
+    let e2 = bdd!(a | b | c).unwrap();
+    let e3 = bdd!(false).unwrap();
 
     println!("{:#?}\n{:#?}\n{:#?}", e1, e2, e3);
 }