Map error with context?

[tmke8]

I'm parsing Rust-style raw strings which can look like: ###"hi"##string continues"### where I need to use context to count the number of hashes. This works with count(), ignore_with_ctx, configure and exactly.

However, in cases where this fails, I want to report a nice error, and for this error I need to know the number of hashes. There is map_err_with_state, which can access the state, but there is no map_err_with that can access the parser context.

Am I missing something and this is somehow possible or is this functionality missing?

EDIT: my current code, in case it helps:

fn raw_string<'src>() -> impl Parser<'src, &'src str, Box<str>, extra::Err<ParseError>> + Clone {
    let matching_hashes = just('#')
        .repeated()
        .configure(|cfg, hash_num| cfg.exactly(*hash_num));
    just('#')
        .repeated()
        .at_least(1)
        .count()
        .then_ignore(just('"'))
        .ignore_with_ctx(
            any()
                .and_is(just('"').then(matching_hashes).not())
                .repeated()
                .to_slice()
                .then(just('"').ignore_then(matching_hashes.ignored()))
                .map_err_with_state(move |e: ParseError, span: SimpleSpan, _state| {
                    let hash_num = ???; // how to get the value in here?
                    if matches!(
                        &e,
                        ParseError::Unexpected {
                            found: TokenFormat::Eoi,
                            ..
                        }
                    ) {
                        e.merge(ParseError::Unclosed {
                            label: "raw string",
                            opened_at: Span::from(span).before_start(hash_num + 2),
                            opened: TokenFormat::OpenRaw(hash_num),
                            expected_at: Span::from(span).at_end(),
                            expected: TokenFormat::CloseRaw(hash_num),
                            found: None.into(),
                        })
                    } else {
                        e
                    }
                }),
        )
        .map(|text| text.0.into())
}

[Zij-IT]

I believe map_with is what you are looking for. The second arg, MapExtra has a ctx method to get the current E::Context, as well as methods for I::Span and E::state (:

[tmke8]

That allows me to map the output in a way that depends on the context, yes. But I wanted to map the error, in order to, well, add more context to it. I did at one point try to store the parser context within the parser state, using map_with (because map_with has access to both), so that I can then retrieve the information with map_err_with_state, but that didn't work somehow because then I had parsers with different types of states, which didn't compile.

Another thing I considered was using validate to create the error (validate has access to the parser context, as does try_map_with actually) but I had trouble making it work in such a way that the right error was propagated out in the end. Maybe I should try again with that approach...

[tmke8]

Oh I see that the MapExtra struct, that map_with gets, also has access to the collected errors. Though this is not publicly exposed.

EDIT: though I think that wouldn't help anyway because map_with wouldn't be called if there's an error, I think

[Zij-IT]

But I wanted to map the error, in order to, well, add more context to it. I did at one point try to store the parser context within the parser state, using map_with (because map_with has access to both), so that I can then retrieve the information with map_err_with_state, but that didn't work somehow because then I had parsers with different types of states, which didn't compile

Oh geez. I'm sorry. I should have had my coffee before I responded 🤦‍♂️ I believe it is a hole in the API that there isn't a map_err_with to compliment map_with. @zesterer open to a PR for a map_err_with and deprecating map_err_with_state in favor of map_err_with?

[tmke8]

I just found a TODO in the code for doing what you propose:

chumsky/src/combinator.rs

Lines 3194 to 3197 in b3c1779

	// TODO: Remove combinator, replace with map_err_with
	/// See [`Parser::map_err_with_state`].
	#[derive(Copy, Clone)]
	pub struct MapErrWithState<A, F> {

So, I'll go ahead with the PR.

[tmke8]

See #951