output unification

src/error.rs

@@ -14,6 +14,8 @@ pub enum Error {
     ProblemCheckFailed,
     #[error("formatting: {_0}")]
     Format(#[from] std::fmt::Error),
+    #[error("outputting: {_0}")]
+    Output(#[from] std::io::Error),
 }
 
 impl From<nom::Err<nom::error::Error<&'_ str>>> for Error {

src/main.rs

@@ -2,7 +2,7 @@
 #![feature(iter_intersperse)]
 #![feature(doc_notable_trait)]
 
-use std::{collections::HashSet, fmt::Write, fs::read_to_string};
+use std::{collections::HashSet, fmt::Write as WriteFmt, fs::read_to_string, io::Write as WriteIo};
 
 use aba::problems::admissibility::{
     EnumerateAdmissibleExtensions, SampleAdmissibleExtension, VerifyAdmissibleExtension,
@@ -35,56 +35,77 @@ mod parser;
 #[cfg(test)]
 mod tests;
 
+trait IccmaFormattable {
+    fn fmt_iccma(&self) -> Result<String>;
+}
+
 fn __main() -> Result {
     let args = args::Args::parse();
 
     let content = read_to_string(&args.file).map_err(Error::OpeningAbaFile)?;
     let aba = parser::aba_file(&content)?;
-    match args.problem {
+    let result = match args.problem {
-        args::Problems::VerifyAdmissibility { set } => {
+        args::Problems::VerifyAdmissibility { set } => aba::problems::solve(
-            let result = aba::problems::solve(
+            VerifyAdmissibleExtension {
-                VerifyAdmissibleExtension {
+                assumptions: set.into_iter().collect(),
-                    assumptions: set.into_iter().collect(),
+            },
-                },
+            &aba,
-                &aba,
+        )?
-            )?;
+        .fmt_iccma(),
-            print_bool_result(result);
-        }
         args::Problems::EnumerateAdmissibility => {
-            let result =
+            aba::problems::multishot_solve(EnumerateAdmissibleExtensions::default(), &aba)?
-                aba::problems::multishot_solve(EnumerateAdmissibleExtensions::default(), &aba)?;
+                .fmt_iccma()
-            print_witnesses_result(result)?;
         }
         args::Problems::SampleAdmissibility => {
-            let result = aba::problems::solve(SampleAdmissibleExtension, &aba)?;
+            aba::problems::solve(SampleAdmissibleExtension, &aba)?.fmt_iccma()
-            print_witness_result(result)?;
         }
+    }?;
+    let mut stdout = std::io::stdout().lock();
+    match writeln!(stdout, "{}", result) {
+        Ok(()) => Ok(()),
+        Err(why) => match why.kind() {
+            std::io::ErrorKind::BrokenPipe => Ok(()),
+            _ => Err(Error::Output(why)),
+        },
     }
-    Ok(())
 }
 
 fn main() -> Result {
     __main().inspect_err(|why| eprintln!("Error: {why}"))
 }
 
-fn print_bool_result(result: bool) {
+impl IccmaFormattable for Vec<HashSet<u32>> {
-    match result {
+    fn fmt_iccma(&self) -> Result<String> {
-        true => println!("YES"),
+        let output = self
-        false => println!("NO"),
+            .iter()
+            .try_fold(String::new(), |mut output, set| -> Result<String> {
+                writeln!(output, "{}", set.fmt_iccma()?)?;
+                Ok(output)
+            })?
+            .trim_end()
+            .to_owned();
+        Ok(output)
     }
 }
 
-fn print_witnesses_result(result: Vec<HashSet<u32>>) -> Result {
+impl IccmaFormattable for HashSet<u32> {
-    result.into_iter().try_for_each(print_witness_result)
+    fn fmt_iccma(&self) -> Result<String> {
+        let set = self
+            .iter()
+            .try_fold(String::new(), |mut list, num| -> Result<_, Error> {
+                write!(list, " {num}")?;
+                Result::Ok(list)
+            })?;
+        Ok(format!("w{set}"))
+    }
 }
 
-fn print_witness_result(result: HashSet<u32>) -> Result {
+impl IccmaFormattable for bool {
-    let set = result
+    fn fmt_iccma(&self) -> Result<String> {
-        .into_iter()
+        let output = match self {
-        .try_fold(String::new(), |mut list, num| -> Result<_, Error> {
+            true => "YES",
-            write!(list, " {num}")?;
+            false => "NO",
-            Result::Ok(list)
+        };
-        })?;
+        Ok(String::from(output))
-    println!("w{set}");
+    }
-    Ok(())
 }