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: Clone,
{
    move |input: I| match parser1.parse(input.clone()) {
        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())
    }
}

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

        //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, parser3].iter() {
            match parser.parse(input.clone()) {
                Ok(result) => return Ok(result),
                Err(e) => {
                    err = Some(e);
                }
            }
        }
        Err(err.unwrap())
    }
}

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

        //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, parser3, parser4].iter() {
            match parser.parse(input.clone()) {
                Ok(result) => return Ok(result),
                Err(e) => {
                    err = Some(e);
                }
            }
        }
        Err(err.unwrap())
    }
}

impl<I, O, E, P1, P2, P3, P4, P5> Choice<I, O, E> for (P1, P2, P3, P4, P5)
where
    P1: Parser<I, O, E>,
    P2: Parser<I, O, E>,
    P3: Parser<I, O, E>,
    P4: Parser<I, O, E>,
    P5: Parser<I, O, E>,
    I: Clone,
{
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        let parser1 = &self.0;
        let parser2 = &self.1;
        let parser3 = &self.2;
        let parser4 = &self.3;
        let parser5 = &self.4;

        //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,
            parser3,
            parser4,
            parser5,
        ]
        .iter()
        {
            match parser.parse(input.clone()) {
                Ok(result) => return Ok(result),
                Err(e) => {
                    err = Some(e);
                }
            }
        }
        Err(err.unwrap())
    }
}

impl<I, O, E, P1, P2, P3, P4, P5, P6> Choice<I, O, E> for (P1, P2, P3, P4, P5, P6)
where
    P1: Parser<I, O, E>,
    P2: Parser<I, O, E>,
    P3: Parser<I, O, E>,
    P4: Parser<I, O, E>,
    P5: Parser<I, O, E>,
    P6: Parser<I, O, E>,
    I: Clone,
{
    fn parse(&self, input: I) -> ParseResult<I, O, E> {
        let parser1 = &self.0;
        let parser2 = &self.1;
        let parser3 = &self.2;
        let parser4 = &self.3;
        let parser5 = &self.4;
        let parser6 = &self.5;

        //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,
            parser3,
            parser4,
            parser5,
            parser6,
        ]
        .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::repeated;
    use crate::primitives::literal;

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