Use trait in choice

src/choice.rs

@@ -1,19 +1,49 @@
-use crate::Parser;
+use crate::{ParseResult, Parser};
 
-pub fn choice<'a, I, O, E>(parsers: &'a [&'a dyn Parser<I, O, E>]) -> impl Parser<I, O, E> + 'a {
-    move |mut input: I| {
-        //TODO need a more principled way to return an error when no choices work
-        let mut err = None;
+pub trait Choice<I, O, E> {
+    fn parse_choice(&self, input: I) -> Result<(O, I), (E, I)>;
+}
 
-        for parser in parsers.iter() {
-            match parser.parse(input) {
-                Ok(res) => return Ok(res),
-                Err((e, rest)) => {
-                    err = Some(e);
-                    input = rest;
-                }
+pub fn choice<C: Choice<I, O, E>, I, O, E>(choices: C) -> impl Parser<I, O, E> {
+    move |input| choices.parse_choice(input)
+}
+
+fn choice_loop<'a, I, O, E>(
+    mut input: I,
+    parsers: &'a [&'a dyn Parser<I, O, E>],
+) -> ParseResult<I, O, E> {
+    //TODO need a more principled way to return an error when no choices work
+    let mut err = None;
+
+    for parser in parsers.iter() {
+        match parser.parse(input) {
+            Ok(res) => return Ok(res),
+            Err((e, rest)) => {
+                err = Some(e);
+                input = rest;
             }
         }
-        Err((err.unwrap(), input))
+    }
+    Err((err.unwrap(), input))
+}
+
+impl<P1, P2, I, O, E> Choice<I, O, E> for (P1, P2)
+where
+    P1: Parser<I, O, E>,
+    P2: Parser<I, O, E>,
+{
+    fn parse_choice(&self, input: I) -> Result<(O, I), (E, I)> {
+        choice_loop(input, &[&self.0, &self.1])
+    }
+}
+
+impl<P1, P2, P3, I, O, E> Choice<I, O, E> for (P1, P2, P3)
+where
+    P1: Parser<I, O, E>,
+    P2: Parser<I, O, E>,
+    P3: Parser<I, O, E>,
+{
+    fn parse_choice(&self, input: I) -> Result<(O, I), (E, I)> {
+        choice_loop(input, &[&self.0, &self.1, &self.2])
     }
 }

src/test/mod.rs

@@ -18,11 +18,7 @@ fn test_sequence() {
 
 #[test]
 fn test_choice() {
-    let a = literal("bongo");
-    let b = literal("sucy");
-    let c = literal("ara");
-    let inputs = [&a as &dyn Parser<&str, &str, ()>, &b, &c];
-    let parser = choice(&inputs);
+    let parser = choice((literal("bongo"), literal("sucy"), literal("ara")));
 
     let output = parser.parse("ara hajimete").unwrap();
     assert_eq!(("ara", " hajimete"), output);
@@ -53,7 +49,7 @@ fn test_optional() {
     let parser = seq2(
         optional(literal("alpha")),
         seq2(repeated(literal(" ")), literal("beta")),
-        );
+    );
 
     let output1 = parser.parse("   beta").unwrap();
     assert_eq!(output1.0 .0, None);