implement representation for json_bool

src/choice/mod.rs

@@ -1,4 +1,4 @@
-use crate::parser::{ParseResult, Parser, ParserInput};
+use crate::parser::{ParseResult, Parser, ParserInput, Representation};
 
 pub fn choice2<P1, P2, I, O, E>(parser1: P1, parser2: P2) -> impl Parser<I, O, E>
 where
@@ -14,11 +14,13 @@ where
     C: Choice<I, O, E>,
     I: ParserInput + Clone,
 {
-    move |input| choices.parse(input)
+    let rep = choices.representation();
+    (move |input| choices.parse(input), rep)
 }
 
 pub trait Choice<I: Clone, O, E> {
     fn parse(&self, input: I) -> ParseResult<I, O, E>;
+    fn representation(&self) -> Representation;
 }
 
 impl<I, O, E, P1, P2> Choice<I, O, E> for (P1, P2)
@@ -31,6 +33,11 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1];
         choice_loop(input, parsers)
     }
+
+    fn representation(&self) -> Representation {
+        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1];
+        repr_loop(parsers)
+    }
 }
 
 impl<I, O, E, P1, P2, P3> Choice<I, O, E> for (P1, P2, P3)
@@ -44,6 +51,11 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2];
         choice_loop(input, parsers)
     }
+
+    fn representation(&self) -> Representation {
+        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2];
+        repr_loop(parsers)
+    }
 }
 
 impl<I, O, E, P1, P2, P3, P4> Choice<I, O, E> for (P1, P2, P3, P4)
@@ -58,6 +70,11 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2, &self.3];
         choice_loop(input, parsers)
     }
+
+    fn representation(&self) -> Representation {
+        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2, &self.3];
+        repr_loop(parsers)
+    }
 }
 
 impl<I, O, E, P1, P2, P3, P4, P5> Choice<I, O, E> for (P1, P2, P3, P4, P5)
@@ -79,6 +96,17 @@ where
         ];
         choice_loop(input, parsers)
     }
+
+    fn representation(&self) -> Representation {
+        let parsers = vec![
+            &self.0 as &dyn Parser<I, O, E>,
+            &self.1,
+            &self.2,
+            &self.3,
+            &self.4,
+        ];
+        repr_loop(parsers)
+    }
 }
 
 impl<I, O, E, P1, P2, P3, P4, P5, P6> Choice<I, O, E> for (P1, P2, P3, P4, P5, P6)
@@ -102,6 +130,17 @@ where
         ];
         choice_loop(input, parsers)
     }
+    fn representation(&self) -> Representation {
+        let parsers = vec![
+            &self.0 as &dyn Parser<I, O, E>,
+            &self.1,
+            &self.2,
+            &self.3,
+            &self.4,
+            &self.5,
+        ];
+        repr_loop(parsers)
+    }
 }
 
 fn choice_loop<I, O, E>(input: I, parsers: Vec<&dyn Parser<I, O, E>>) -> ParseResult<I, O, E>
@@ -122,6 +161,14 @@ where
     Err(err.unwrap())
 }
 
+fn repr_loop<I, O, E>(parsers: Vec<&dyn Parser<I, O, E>>) -> Representation
+where
+    I: ParserInput + Clone,
+{
+    let mut iter = parsers.iter().map(|p| p.representation());
+    Representation::from_choice(&mut iter)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/parser/representation.rs

@@ -9,4 +9,26 @@ impl Representation {
             val: from.to_string(),
         }
     }
+
+    pub fn from_choice(choice_parser_reps: &mut impl Iterator<Item = Representation>) -> Self {
+        let mut buf = String::new();
+        let mut iter = choice_parser_reps.peekable();
+        loop {
+            let rep = match iter.next() {
+                Some(r) => r,
+                None => break,
+            };
+            buf.push_str(&rep.val);
+            match iter.peek() {
+                Some(_) => {
+                    buf.push_str(" | ");
+                }
+                None => {
+                    break;
+                }
+            }
+        }
+
+        Representation::new(&buf)
+    }
 }

tests/json_parser.rs

@@ -240,4 +240,8 @@ fn parse_json_document() {
 #[test]
 fn test_representations() {
     assert_eq!(json_null().representation(), Representation::new("null"));
+    assert_eq!(
+        json_bool().representation(),
+        Representation::new("true | false")
+    );
 }