Remove current iteration of bnf code

src/bnf.rs

@@ -1,6 +0,0 @@
-#[derive(Debug, Clone, PartialEq)]
-pub enum Bnf {
-    Production,
-    Choice(Vec<Bnf>),
-    Unknown,
-}

src/choice/mod.rs

@@ -1,4 +1,3 @@
-use crate::bnf::Bnf;
 use crate::parser::{ParseResult, Parser, ParserInput};
 
 pub fn choice2<P1, P2, I, O, E>(parser1: P1, parser2: P2) -> impl Parser<I, O, E>
@@ -10,19 +9,16 @@ where
     choice((parser1, parser2))
 }
 
-pub fn choice<C, I, O, E>(choices: C) -> (impl Parser<I, O, E>, Bnf)
+pub fn choice<C, I, O, E>(choices: C) -> impl Parser<I, O, E>
 where
     C: Choice<I, O, E>,
     I: ParserInput + Clone,
 {
-    let bnf = choices.bnf();
+    move |input| choices.parse(input)
-    (move |input| choices.parse(input), bnf)
 }
 
 pub trait Choice<I: Clone, O, E> {
     fn parse(&self, input: I) -> ParseResult<I, O, E>;
-
-    fn bnf(&self) -> Bnf;
 }
 
 impl<I, O, E, P1, P2> Choice<I, O, E> for (P1, P2)
@@ -35,16 +31,6 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1];
         choice_loop(input, parsers)
     }
-
-    fn bnf(&self) -> Bnf {
-        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1];
-        Bnf::Choice(
-            parsers
-                .into_iter()
-                .map(|p| p.bnf().unwrap_or(Bnf::Unknown))
-                .collect(),
-        )
-    }
 }
 
 impl<I, O, E, P1, P2, P3> Choice<I, O, E> for (P1, P2, P3)
@@ -58,16 +44,6 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2];
         choice_loop(input, parsers)
     }
-
-    fn bnf(&self) -> Bnf {
-        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2];
-        Bnf::Choice(
-            parsers
-                .into_iter()
-                .map(|p| p.bnf().unwrap_or(Bnf::Unknown))
-                .collect(),
-        )
-    }
 }
 
 impl<I, O, E, P1, P2, P3, P4> Choice<I, O, E> for (P1, P2, P3, P4)
@@ -82,16 +58,6 @@ where
         let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2, &self.3];
         choice_loop(input, parsers)
     }
-
-    fn bnf(&self) -> Bnf {
-        let parsers = vec![&self.0 as &dyn Parser<I, O, E>, &self.1, &self.2, &self.3];
-        Bnf::Choice(
-            parsers
-                .into_iter()
-                .map(|p| p.bnf().unwrap_or(Bnf::Unknown))
-                .collect(),
-        )
-    }
 }
 
 impl<I, O, E, P1, P2, P3, P4, P5> Choice<I, O, E> for (P1, P2, P3, P4, P5)
@@ -113,22 +79,6 @@ where
         ];
         choice_loop(input, parsers)
     }
-
-    fn bnf(&self) -> Bnf {
-        let parsers = vec![
-            &self.0 as &dyn Parser<I, O, E>,
-            &self.1,
-            &self.2,
-            &self.3,
-            &self.4,
-        ];
-        Bnf::Choice(
-            parsers
-                .into_iter()
-                .map(|p| p.bnf().unwrap_or(Bnf::Unknown))
-                .collect(),
-        )
-    }
 }
 
 impl<I, O, E, P1, P2, P3, P4, P5, P6> Choice<I, O, E> for (P1, P2, P3, P4, P5, P6)
@@ -152,23 +102,6 @@ where
         ];
         choice_loop(input, parsers)
     }
-
-    fn bnf(&self) -> Bnf {
-        let parsers = vec![
-            &self.0 as &dyn Parser<I, O, E>,
-            &self.1,
-            &self.2,
-            &self.3,
-            &self.4,
-            &self.5,
-        ];
-        Bnf::Choice(
-            parsers
-                .into_iter()
-                .map(|p| p.bnf().unwrap_or(Bnf::Unknown))
-                .collect(),
-        )
-    }
 }
 
 fn choice_loop<I, O, E>(input: I, parsers: Vec<&dyn Parser<I, O, E>>) -> ParseResult<I, O, E>

src/lib.rs

@@ -1,4 +1,3 @@
-mod bnf;
 pub mod choice;
 pub mod combinators;
 mod parser;
@@ -6,7 +5,6 @@ pub mod primitives;
 pub mod sequence;
 
 #[cfg(test)]
-use bnf::Bnf;
 pub use parser::{ParseResult, Parser, ParserInput};
 
 #[cfg(test)]
@@ -223,13 +221,4 @@ mod tests {
         let parsed_json = json_object().parse(test_json);
         assert!(parsed_json.is_ok());
     }
-
-    #[test]
-    fn bnf_representation() {
-        let bnf = json_value().bnf().unwrap();
-        assert_eq!(bnf, Bnf::Production);
-
-        let bnf = json_object().bnf().unwrap();
-        assert_eq!(bnf, Bnf::Production);
-    }
 }

src/parser/boxed_parser.rs

@@ -1,4 +1,3 @@
-use crate::bnf::Bnf;
 use crate::parser::{ParseResult, Parser, ParserInput};
 
 pub struct BoxedParser<'a, I, O, E>
@@ -27,10 +26,6 @@ impl<'a, I: ParserInput, O, E> Parser<I, O, E> for BoxedParser<'a, I, O, E> {
         self.inner.parse(input)
     }
 
-    fn bnf(&self) -> Option<Bnf> {
-        self.inner.bnf()
-    }
-
     fn boxed<'b>(self) -> BoxedParser<'b, I, O, E>
     where
         Self: Sized + 'b,

src/parser/mod.rs

@@ -1,7 +1,6 @@
 mod boxed_parser;
 mod named_parser;
 
-use crate::bnf::Bnf;
 use std::rc::Rc;
 
 pub use boxed_parser::BoxedParser;
@@ -19,9 +18,6 @@ where
     I: ParserInput,
 {
     fn parse(&self, input: I) -> ParseResult<I, O, E>;
-    fn bnf(&self) -> Option<Bnf> {
-        None
-    }
 
     fn boxed<'a>(self) -> BoxedParser<'a, I, O, E>
     where
@@ -150,19 +146,6 @@ where
     }
 }
 
-impl<I: ParserInput, O, E, P> Parser<I, O, E> for (P, Bnf)
-where
-    P: Parser<I, O, E>,
-{
-    fn parse(&self, input: I) -> ParseResult<I, O, E> {
-        self.0.parse(input)
-    }
-
-    fn bnf(&self) -> Option<Bnf> {
-        Some(self.1.clone())
-    }
-}
-
 impl<I, O, E, T> Parser<I, O, E> for Rc<T>
 where
     I: ParserInput,
@@ -171,8 +154,4 @@ where
     fn parse(&self, input: I) -> ParseResult<I, O, E> {
         self.as_ref().parse(input)
     }
-
-    fn bnf(&self) -> Option<Bnf> {
-        self.as_ref().bnf()
-    }
 }

src/parser/named_parser.rs

@@ -1,5 +1,4 @@
 use crate::parser::{ParseResult, Parser, ParserInput};
-//use crate::bnf::Bnf;
 use super::boxed_parser::BoxedParser;
 
 pub struct NamedParser<'a, I, O, E>

src/sequence/mod.rs

@@ -1,4 +1,4 @@
-use crate::{ParseResult, Parser, ParserInput};
+use crate::parser::{ParseResult, Parser, ParserInput};
 
 pub fn tuple2<P1, P2, I, O1, O2, E>(parser1: P1, parser2: P2) -> impl Parser<I, (O1, O2), E>
 where