Ensure complete parsing without SOI and EOI

[teiesti]

Is is possible to ensure complete parsing without the use of SOI and EOI, e.g., through a Parser::parse_complete(my_rule, my_string).

Background:

My actual use case is much more complex but let's suppose I have a grammar like

number = { ASCII_DIGIT* }
sum = { number ~ "+" ~ number }

I want to use this grammar to parse both numbers and sums. When parsing a number I do not want to allow something like 1+1 for obvious reasons. Anyhow, running Parser::parse(Rule::number, "1+1") won't fail as expected as the parser will simply accept the first 1 in the string and return it.

Of course, I can work around this problem by adding a rule

full_number = _{ SOI ~ number ~ EOI }

and run Parser::parse(Rule::full_number, "1+1") instead.

Anyhow, let's now suppose I also want to parse sums and do not want to accept, e.g., "1+1+1". I would end up with yet another rule

full_sum = _{ SOI ~ sum ~ EOI }

which is (mostly) a duplication of full_number.

Is there any possibility to avoid all these full_* rules (In my actual use case I have at lot of them!) and use something like a Parser::parse_complete(my_rule, my_string) which has the same behavior like Parser::parse(full_my_rule, my_string) with an additional rule full_my_rule = _{ SOI ~ my_rule ~ EOI }?

Thanks!

[tomtau]

Not sure what all the rules look like, but if they are non-overlapping, one could perhaps have a single joint rule full_my_rule = _{ SOI ~ (my_rule1 | my_rule2 | ...) ~ EOI } ?

[teiesti]

Thanks for the answer. Unfortunately, the rules are overlapping. To solve the issue, I went the long way and implemented my own custom "parser extension".

use pest::{
    error::{Error, ErrorVariant},
    iterators::Pairs,
    Parser, Position, RuleType,
};

pub trait CompleteParser<R: RuleType>: Parser<R> {
    fn parse_complete(rule: R, input: &str) -> Result<Pairs<'_, R>, Error<R>> {
        Self::parse(rule, input).and_then(|pairs| {
            if pairs.as_str() == input {
                Ok(pairs)
            } else {
                Err(Error::new_from_pos(
                    ErrorVariant::CustomError {
                        message: String::from("expected EOI"),
                    },
                    Position::new(input, pairs.as_str().len()).unwrap(),
                ))
            }
        })
    }
}

impl<P: Parser<R>, R: RuleType> CompleteParser<R> for P {}