cut_err behavior on nesting alt

[7sDream]

For the following example:

dec ::= '@' digit+ 
hex ::= '#' ( '0' .. '9' | 'a' .. 'f' )+
number ::= dec | hex
ident ::= '@' ( 'a' .. 'z' )+
item ::= number | ident
code ::= item ( ' ' item )* | <EOF>

#[cfg(test)]
mod test {
    use winnow::{
        ModalResult,
        ascii::{alpha1, digit1, hex_digit1},
        combinator::{alt, cut_err, fail, preceded, separated},
        error::{StrContext, StrContextValue},
        prelude::*,
    };

    #[test]
    fn test_alt_cut_err() {
        #[derive(Debug)]
        enum Number {
            At(usize),
            Hash(usize),
        }

        #[derive(Debug)]
        struct Ident<'s>(&'s str);

        #[derive(Debug)]
        enum Item<'s> {
            Number(Number),
            Ident(Ident<'s>),
        }

        fn dec_num(input: &mut &str) -> ModalResult<usize> {
            digit1
                .verify_map(|x: &str| x.parse::<usize>().ok())
                .parse_next(input)
        }

        fn hex_num(input: &mut &str) -> ModalResult<usize> {
            hex_digit1
                .verify_map(|x: &str| usize::from_str_radix(x, 16).ok())
                .parse_next(input)
        }

        fn number(input: &mut &str) -> ModalResult<Number> {
            alt((
                preceded(
                    '@',
                    cut_err(dec_num).context(StrContext::Expected(StrContextValue::Description(
                        "Dec number",
                    ))),
                )
                .map(Number::At),
                preceded(
                    '#',
                    cut_err(hex_num).context(StrContext::Expected(StrContextValue::Description(
                        "Hex number",
                    ))),
                )
                .map(Number::Hash),
            ))
            .parse_next(input)
        }

        fn ident<'s>(input: &mut &'s str) -> ModalResult<Ident<'s>> {
            preceded(
                '@',
                alpha1.context(StrContext::Expected(StrContextValue::Description("Ident"))),
            )
            .map(Ident)
            .parse_next(input)
        }

        fn parser<'s>(input: &mut &'s str) -> ModalResult<Vec<Item<'s>>> {
            separated(
                0..,
                alt((
                    number.map(Item::Number),
                    ident.map(Item::Ident),
                    cut_err(fail).context(StrContext::Label("Unknown item")),
                )),
                ' ',
            )
            .parse_next(input)
        }

        let content: &str = "@1 #f @ident";
        let items = parser.parse(content).unwrap();
        println!("{:?}", items);
    }
}

Result:

called `Result::unwrap()` on an `Err` value: ParseError { input: "@1 #f @ident", offset: 7, inner: ContextError { context: [Expected(Description("Dec number"))], cause: None } }

In this example, the grammar specifies that both number and ident can be prefixed with @. For clarity of structure of parser, we chose to handle Number and Ident separately.

The number parser uses cut_err. As a result, in the top level parser function, even though cut_err isn't used here, once the attempt to match a number with the @ prefix fails, the parser won't proceed to try matching an ident.

Although in this simple case we could restructure the code to handle number and ident together, in more complex grammars such restructuring might significantly diverge the code structure from the actual grammar, harming maintainability.

Could we design a version of cut_err that only affects a single nesting level—i.e., it cuts off further attempts only within the nearest enclosing alt, without interfering with any outer alt? But this seems need a new variant in ErrMode, alternatively, maybe provide a different variant of alt that converts internal unrecoverable errors into backtrace?

[epage]

You can use backtrack_err in number around alt to workaround it in this particular case.

However, where possible, the best route is to restructure. I recommend limiting cut_err to truly final errors. Personally, I'd also swap in dispatch! in place of alt.

[7sDream]

Yes, restructuring is the best approach in this case, but making every part of the parser modular can also be useful, for example, when it’s used in many different places.

The backtrace_err is exactly what I need for now. Thanks for your quick help!