rust-parser-combinator/src/choice.rs

use crate::parser::{ParseResult, Parser};

pub fn choice2<P1, P2, I, O, E>(parser1: P1, parser2: P2) -> impl Parser<I, O, E>
where
    P1: Parser<I, O, E>,
    P2: Parser<I, O, E>,
    I: Copy,
{
    move |input| match parser1.parse(input) {
        ok @ Ok(..) => ok,
        Err(_e) => parser2.parse(input),
    }
}

pub fn choice<C, I, O, E>(choices: C) -> impl Parser<I, O, E>
where
    C: Choice<I, O, E>,
    I: Clone,
{
    move |input| choices.parse(input)
}

pub trait Choice<I: Clone, O, E> {
    fn parse(&self, input: I) -> ParseResult<I, O, E>;
}

impl<I, O, E, P1, P2> Choice<I, O, E> for (P1, P2)
where
    P1: Parser<I, O, E>,
    P2: Parser<I, O, E>,
    I: Clone,
{
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        let parser1 = &self.0;
        let parser2 = &self.1;

        //TODO need a more principled way to return an error when no choices work
        let mut err = None;

        for parser in [parser1 as &dyn Parser<I, O, E>, parser2].iter() {
            match parser.parse(input.clone()) {
                Ok(result) => return Ok(result),
                Err(e) => {
                    err = Some(e);
                }
            }
        }
        Err(err.unwrap())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::combinators::one_or_more;
    use crate::primitives::literal;

    #[test]
    fn test_choice() {
        let p = choice2(literal("gnostika").to(1), one_or_more(literal(" ")).to(2));
        assert_eq!(p.parse("gnostika twentynine"), Ok((1, " twentynine")));
    }
}