handle fallible generators

Author: remi-dupre

.github/workflows/tests.yml

@@ -26,3 +26,6 @@ jobs:
 
       - name: Format
         run: cargo fmt -- --check
+
+      - name: Run example
+        run: echo "42" | cargo run --bin example -- -i

src/input.rs

@@ -19,7 +19,7 @@ pub fn get_input(year: u16, day: u8) -> Result<String, Box<dyn Error>> {
             .send()?;
         let elapsed = start.elapsed();
 
-        crate::print_with_duration("downloaded input file", None, elapsed);
+        crate::print_with_duration("downloaded input file", None, Some(elapsed));
         resp.text()
     })?;
 

src/lib.rs

@@ -1,6 +1,7 @@
 pub mod input;
 pub mod parse;
 pub mod run;
+pub mod try_unwrap;
 
 use std::cmp::min;
 use std::iter;
@@ -9,16 +10,20 @@ use std::time::Duration;
 
 // Reexport some crates for the generated main
 pub use clap;
+pub use colored;
 pub use criterion;
 
 use clap::Clap;
 use colored::*;
 
 const DISPLAY_WIDTH: usize = 40;
 
-pub fn print_with_duration(line: &str, output: Option<&str>, duration: Duration) {
-    let duration = format!("({:.2?})", duration);
-    print!("  - {} {}", line, duration.dimmed());
+pub fn print_with_duration(line: &str, output: Option<ColoredString>, duration: Option<Duration>) {
+    let duration = duration
+        .map(|duration| format!(" ({:.2?})", duration))
+        .unwrap_or_else(String::new);
+
+    print!("  - {}{}", line, duration.dimmed());
 
     if let Some(output) = output {
         let width = "  - ".len() + line.chars().count() + 1 + duration.chars().count();

src/parse.rs

@@ -2,20 +2,28 @@
 // $ctx, { day DAY { { gen GENERATOR } { { sol SOLUTION } { sol SOLUTION } } } }
 #[macro_export]
 macro_rules! parse {
-    // Read day
+    // Read day: default generator
+    (
+        day $apply: ident, $ctx: tt, $val: expr;
+        $day: ident => $( $tail: tt )*
+    ) => {
+        $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen_default } { } } }; $( $tail )* )
+    };
+
+    // Read day: regular generator
     (
         day $apply: ident, $ctx: tt, $val: expr;
         $day: ident : $generator: ident => $( $tail: tt )*
     ) => {
         $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen $generator } { } } }; $( $tail )* )
     };
 
-    // Read day: default generator
+    // Read day: fallible generator
     (
         day $apply: ident, $ctx: tt, $val: expr;
-        $day: ident => $( $tail: tt )*
+        $day: ident : $generator: ident ? => $( $tail: tt )*
     ) => {
-        $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen_default } { } } }; $( $tail )* )
+        $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen_fallible $generator } { } } }; $( $tail )* )
     };
 
     // Empty rules

src/run.rs

@@ -4,6 +4,8 @@ macro_rules! run_day {
         { $i: expr, $curr_day: expr, $year: expr, $opt: expr },
         { day $day: ident { $gen: tt { $( { sol $solution: ident } )* } } }
     ) => {{
+        use $crate::colored::*;
+
         if stringify!($day) == $curr_day {
             if $i != 0 { println!() }
             let day = $curr_day[3..].parse().expect("days must be integers");
@@ -23,19 +25,27 @@ macro_rules! run_day {
                 }
             };
 
-            let input = $crate::run_gen!($day, &data, $gen);
-
-            $({
-                let start = Instant::now();
-                let response = $day::$solution(&input);
-                let elapsed = start.elapsed();
+            if let Some(input) = $crate::run_gen!($day, &data, $gen) {
+                $({
+                    let start = Instant::now();
+                    let response = $day::$solution(&input);
+                    let elapsed = start.elapsed();
 
-                $crate::print_with_duration(
-                    stringify!($solution),
-                    Some(&format!("{}", response)),
-                    elapsed,
-                );
-            })+
+                    $crate::print_with_duration(
+                        stringify!($solution),
+                        Some(format!("{}", response).normal()),
+                        Some(elapsed),
+                    );
+                })+
+            } else {
+                $({
+                    $crate::print_with_duration(
+                        stringify!($solution),
+                        Some("skipped".dimmed()),
+                        None,
+                    );
+                })+
+            }
         }
     }}
 }
@@ -44,15 +54,36 @@ macro_rules! run_day {
 macro_rules! run_gen {
     // No generator is needed: default begavior is to just pass input &str
     ( $day: ident, $data: expr, { gen_default } ) => {{
-        $data
+        Some($data)
     }};
 
     // Run generator
     ( $day: ident, $data: expr, { gen $generator: ident } ) => {{
         let start = Instant::now();
         let input = $day::$generator($data);
         let elapsed = start.elapsed();
-        $crate::print_with_duration("generator", None, elapsed);
-        input
+        $crate::print_with_duration("generator", None, Some(elapsed));
+        Some(input)
+    }};
+
+    // Run fallible generator
+    ( $day: ident, $data: expr, { gen_fallible $generator: ident } ) => {{
+        use $crate::colored::*;
+        use $crate::try_unwrap::TryUnwrap;
+
+        let start = Instant::now();
+        let result = $day::$generator($data);
+        let elapsed = start.elapsed();
+
+        match result.try_unwrap() {
+            Ok(input) => {
+                $crate::print_with_duration("generator", None, Some(elapsed));
+                Some(input)
+            }
+            Err(msg) => {
+                $crate::print_with_duration("generator", Some(msg.red()), Some(elapsed));
+                None
+            }
+        }
     }};
 }

src/try_unwrap.rs

@@ -0,0 +1,26 @@
+use std::fmt::Display;
+
+pub trait TryUnwrap {
+    type Val;
+    fn try_unwrap(self) -> Result<Self::Val, String>;
+}
+
+impl<T> TryUnwrap for Option<T> {
+    type Val = T;
+
+    fn try_unwrap(self) -> Result<Self::Val, String> {
+        if let Some(val) = self {
+            Ok(val)
+        } else {
+            Err("empty output".to_string())
+        }
+    }
+}
+
+impl<T, E: Display> TryUnwrap for Result<T, E> {
+    type Val = T;
+
+    fn try_unwrap(self) -> Result<Self::Val, String> {
+        self.map_err(|err| format!("{}", err))
+    }
+}