Add an optional fallback transition to each state (#49)

Cargo.toml

@@ -8,6 +8,13 @@ license = "MPL-2.0"
 repository = "https://github.com/wrsturgeon/inator"
 build = "build.rs"
 
+[workspace]
+members = [
+  "automata",
+  "automata/examples/matched_parentheses_codegen",
+  "examples/json",
+]
+
 [dependencies]
 inator-automata = { path = "automata" }
 

automata/src/combinators.rs

@@ -116,6 +116,9 @@ fn add_tail_call_state<I: Input, C: Ctrl<I>>(
     State {
         transitions: add_tail_call_curry(s.transitions, other_init, accepting_indices),
         non_accepting: s.non_accepting,
+        fallback: s
+            .fallback
+            .map(|f| add_tail_call_transition(f, other_init, accepting_indices)),
     }
 }
 

automata/src/generalize.rs

@@ -27,6 +27,7 @@ impl<I: Input, C: Ctrl<I>> State<I, C> {
         State {
             transitions: self.transitions.generalize(),
             non_accepting: self.non_accepting,
+            fallback: self.fallback.map(Transition::generalize),
         }
     }
 }

automata/src/graph.rs

@@ -146,10 +146,12 @@ impl<I: Input, C: Ctrl<I>> Graph<I, C> {
                     let State {
                         transitions,
                         non_accepting,
+                        fallback,
                     } = unwrap!(subsets_as_states.remove(set));
                     State {
                         transitions: fix_indices_curry(transitions, &ordering),
                         non_accepting,
+                        fallback: fallback.map(|f| fix_indices_transition(f, &ordering)),
                     }
                 })
                 .collect(),
@@ -181,6 +183,7 @@ impl<I: Input, C: Ctrl<I>> Graph<I, C> {
             None => State {
                 transitions: Curry::Scrutinize(RangeMap(BTreeMap::new())),
                 non_accepting: iter::once("Unexpected token".to_owned()).collect(),
+                fallback: None,
             },
             // If they successfully merged, return the merged state
             Some(Ok(ok)) => ok,
@@ -193,6 +196,10 @@ impl<I: Input, C: Ctrl<I>> Graph<I, C> {
             .transitions
             .values()
             .flat_map(|t| t.dsts().into_iter().cloned())
+            .chain(mega_state.fallback.as_ref().map_or_else(
+                || vec![].into_iter().cloned(),
+                |f| f.dsts().into_iter().cloned(),
+            ))
             .collect();
 
         // Insert the finished value (also to tell all below iterations that we've covered this case)

automata/src/in_progress.rs

@@ -116,7 +116,8 @@ fn step<I: Input, C: Ctrl<I>>(
     // Merge into a huge aggregate transition and act on that instead of individual transitions
     match try_merge(states.filter_map(|s| match s.transitions.get(&token) {
         Err(e) => Some(Err(e)),
-        Ok(opt) => opt.map(|t| Ok(t.clone())),
+        Ok(None) => s.fallback.as_ref().map(|t| Ok(t.clone())),
+        Ok(Some(t)) => Some(Ok(t.clone())),
     })) {
         None => Err(ParseError::BadInput(InputError::Absurd)),
         Some(Err(e)) => Err(ParseError::BadParser(e)),

automata/src/lib.rs

@@ -247,6 +247,7 @@ pub fn dyck_d() -> Deterministic<char> {
                 .collect(),
             )),
             non_accepting: BTreeSet::new(),
+            fallback: None,
         }],
         initial: 0,
     }
@@ -280,6 +281,7 @@ pub fn dyck_nd() -> Nondeterministic<char> {
                 .collect(),
             )),
             non_accepting: BTreeSet::new(),
+            fallback: None,
         }],
         initial: iter::once(0).collect(),
     }

automata/src/merge.rs

@@ -122,6 +122,10 @@ impl<I: Input, C: Ctrl<I>> Merge for State<I, C> {
                 self.non_accepting.extend(other.non_accepting);
                 self.non_accepting
             },
+            fallback: self
+                .fallback
+                .merge(other.fallback)
+                .map_or_else(|(a, b)| a.merge(b).map(Some), Ok)?,
         })
     }
 }

automata/src/qc.rs

@@ -120,11 +120,16 @@ macro_rules! shrink_only {
 }
 
 shrink_only!(|self: &State| Box::new(
-    (self.transitions.clone(), self.non_accepting.clone(),)
+    (
+        self.transitions.clone(),
+        self.non_accepting.clone(),
+        self.fallback.clone()
+    )
         .shrink()
-        .map(|(transitions, non_accepting)| Self {
+        .map(|(transitions, non_accepting, fallback)| Self {
             transitions,
             non_accepting,
+            fallback
         })
 ));
 
@@ -190,6 +195,7 @@ impl<C: Ctrl<u8>> State<u8, C> {
         Self {
             transitions: Curry::arbitrary_given(n_states, g),
             non_accepting: BTreeSet::arbitrary(g),
+            fallback: bool::arbitrary(g).then(|| Transition::arbitrary_given(n_states, g)),
         }
     }
 }

automata/src/reindex.rs

@@ -21,6 +21,7 @@ impl<I: Input, C: Ctrl<I>> State<I, C> {
         State {
             transitions: self.transitions.reindex(states, index_map),
             non_accepting: self.non_accepting.clone(),
+            fallback: self.fallback.as_ref().map(|f| f.reindex(states, index_map)),
         }
     }
 }

automata/src/state.rs

@@ -6,7 +6,7 @@
 
 //! State, i.e. a node in an automaton graph.
 
-use crate::{Ctrl, Curry, IllFormed, Input};
+use crate::{Ctrl, Curry, IllFormed, Input, Transition};
 use core::cmp;
 use std::collections::BTreeSet;
 
@@ -18,6 +18,8 @@ pub struct State<I: Input, C: Ctrl<I>> {
     pub transitions: Curry<I, C>,
     /// If input ends while in this state, should we accept?
     pub non_accepting: BTreeSet<String>,
+    /// If no other transitions work, take this one (if any).
+    pub fallback: Option<Transition<I, C>>,
 }
 
 impl<I: Input, C: Ctrl<I>> State<I, C> {
@@ -47,6 +49,7 @@ impl<I: Input> State<I, usize> {
         State {
             transitions: self.transitions.convert_ctrl(),
             non_accepting: self.non_accepting,
+            fallback: self.fallback.map(Transition::convert_ctrl),
         }
     }
 }
@@ -57,6 +60,7 @@ impl<I: Input, C: Ctrl<I>> Clone for State<I, C> {
         Self {
             transitions: self.transitions.clone(),
             non_accepting: self.non_accepting.clone(),
+            fallback: self.fallback.clone(),
         }
     }
 }

automata/src/test.rs

@@ -312,6 +312,7 @@ mod reduced {
                 states: vec![State {
                     transitions: Curry::Wildcard(Transition::Return { region: "region" }),
                     non_accepting: BTreeSet::new(),
+                    fallback: None,
                 }],
                 initial: 0,
             },
@@ -330,18 +331,22 @@ mod reduced {
                             update: update!(|(), _| {}),
                         }),
                         non_accepting: BTreeSet::new(),
+                        fallback: None,
                     },
                     State {
                         transitions: Curry::Wildcard(Transition::Return { region: "region" }),
                         non_accepting: BTreeSet::new(),
+                        fallback: None,
                     },
                     State {
                         transitions: Curry::Scrutinize(RangeMap(BTreeMap::new())),
                         non_accepting: BTreeSet::new(),
+                        fallback: None,
                     },
                     State {
                         transitions: Curry::Wildcard(Transition::Return { region: "region" }),
                         non_accepting: iter::once(String::new()).collect(),
+                        fallback: None,
                     },
                     State {
                         transitions: Curry::Wildcard(Transition::Call {
@@ -356,11 +361,37 @@ mod reduced {
                             },
                         }),
                         non_accepting: BTreeSet::new(),
+                        fallback: None,
                     },
                 ],
                 initial: 0,
             },
             vec![],
         );
     }
+
+    #[test]
+    fn determinize_identity_2() {
+        determinize_identity(
+            &Graph {
+                states: vec![
+                    State {
+                        transitions: Curry::Wildcard(Transition::Return { region: "region" }),
+                        non_accepting: BTreeSet::new(),
+                        fallback: None,
+                    },
+                    State {
+                        transitions: Curry::Scrutinize(RangeMap(BTreeMap::new())),
+                        non_accepting: BTreeSet::new(),
+                        fallback: Some(Transition::Lateral {
+                            dst: 0,
+                            update: update!(|_: u8, _| ()),
+                        }),
+                    },
+                ],
+                initial: 1,
+            },
+            vec![],
+        );
+    }
 }

automata/src/to_src.rs

@@ -267,6 +267,10 @@ impl<I: Input> State<I, usize> {
                     + "] })"
             },
         );
+        let on_unrecognized = self.fallback.as_ref().map_or_else(
+            || "Err(Error::Absurd { index, token })".to_owned(),
+            Transition::to_src,
+        );
         Ok(format!(
             r#"
 
@@ -276,7 +280,7 @@ fn state_{i}<I: Iterator<Item = (usize, {token_t})>>(input: &mut I, acc: {input_
     match input.next() {{
         None => {on_none},
         Some((index, token)) => match token {{{on_some}
-            _ => Err(Error::Absurd {{ index, token }}),
+            _ => {on_unrecognized},
         }},
     }}
 }}"#,

src/lib.rs

@@ -175,6 +175,7 @@ pub fn empty<I: Input>() -> Deterministic<I> {
         states: vec![State {
             transitions: Curry::Scrutinize(RangeMap(BTreeMap::new())),
             non_accepting: BTreeSet::new(),
+            fallback: None,
         }],
         initial: 0,
     }
@@ -189,6 +190,7 @@ pub fn any_of<I: Input>(range: Range<I>, update: Update<I>) -> Deterministic<I>
             State {
                 transitions: Curry::Scrutinize(RangeMap(BTreeMap::new())),
                 non_accepting: BTreeSet::new(),
+                fallback: None,
             },
             State {
                 non_accepting: iter::once(format!(
@@ -200,6 +202,7 @@ pub fn any_of<I: Input>(range: Range<I>, update: Update<I>) -> Deterministic<I>
                 transitions: Curry::Scrutinize(RangeMap(
                     iter::once((range, Transition::Lateral { dst: 0, update })).collect(),
                 )),
+                fallback: None,
             },
         ],
         initial: 1,