Need help with parsing-flow.

[TornaxO7]

Hello! Currently I have the following similar code:

fn get_parser() -> impl Parser<char, Token, Error = Simple<char>> {
    // ...

    get_parser1()
        .or(get_parser2())
        .or(get_parser3())
}

but now I'd like to add a strategy, to abort the whole parsing-process if
needed. My first idea was to use or_else for this:

#[derive(Debug, Clone, PartialEq, Eq)]
enum ErrorStrategy {
    Abort,
    Recovery,
}

impl chumsky::Error<char> for ErrorStrategy {
    // ...
}

fn get_parser() -> impl Parser<char, Token, Error = ErrorStrategy> {
    // ...

    get_parser1()
        .or_else(|error| match error {
            ErrorStrategy::Abort => {
                // how can I abort the whole parsing-process so that `.or(get_parser3())` doesn't get called?
            },
            ErrorStrategy::Recovery => {
                // I'd like to fire another parser here, but how can I accomplish this?
                // I need the part where `get_parser1()` failed, so I'd need to store the last
                // cursor part somehow in the `ErrorStrategy` Enum, right?
                get_recovery_parser().parse(???)
            }
        })
        .or(get_parser3())
        .repeated()
}

I'm pretty much stuck here and I don't really know how I can implement this with chumsky.

[zesterer]

This feels like an A/B problem. Why do you want to abort the parsing process?

[TornaxO7]

I'm coming from the rfc2047-decoder crate.
To sum it up: I'd like to allow the programmer to decide on his/her own what
should happen if an encoded word is too long as the standard allows.

The function which returns the parser looks like this:

#[derive(Debug, Clone, PartialEq, Eq)]
enum ErrorStrategy {
    /// Abort the parsing process if the encoded word is too long and return an
    /// error
    Abort,

    /// Skip the wrong encoded word and parse it as clear text
    Skip,

    /// Decode the encoded word, although the encoded word is too long
    Decode,
}

fn get_parser(too_long_strategy: ErrorStrategy) -> impl Parser<...> {
    // ...

    encoded_words_parser(too_long_strategy)
        .or(single_encoded_word_parser(too_long_strategy))
        .or(clear_text_parser())
        .repeated()
}

Now I want the parser from get_parser to abort (in this case, not starting
the clear_text_parser) if the single_encoded_word_parser fails and the
developer set the error strategy to ErrorStrategy::Abort.

Does that give you enough context? Feel free to ask, if something is still unclear.

[zesterer]

Right. This sounds like you want to have your parser be built up at runtime. I would suggest something like the following:

fn get_parser(too_long_strategy: ErrorStrategy) -> impl Parser<...> {
    // ...

    let parser = encoded_words_parser(too_long_strategy);
    
    if too_long_strategy == ErrorStrategy::Abort {
        parser.boxed()
    } else {
        parser
            .or(single_encoded_word_parser(too_long_strategy))
            .or(clear_text_parser())
            .boxed()
    }
        .repeated()
}

This allows the structure of the parser to be determined on creation.

[TornaxO7]

Thank you for the fast answer!
I'll see how far I can get with this :)