Way to quickly throw an error?

[BinaryQuantumSoul]

Right now the only usable way I've found to throw errors in specific pattern mistakes is using:

just("]").or_not().try_map(|o,e| o.unwrap_or_else(Err(Rich::custom(e.span(), MyError::Error1)))

when something is unterminated
or

just("!").to(None).try_map(|o,e| o.unwrap_or_else(Err(Rich::custom(e.span(), MyError::Error1)))

when something is forbidden. The to(None) os to reuse same format as prior.

But this is quite a lot of boilerplate and it also forces to convert MyError to String (I don't kow why Rich::custom forces strings, but implementing my own error type for this seems like huge work with a lot of duplication) and parse it back from string after parsing.

Is there a better way? map_err seems even more cumbersome.

[Zij-IT]

Could you elaborate on the use case? Your first example for throwing an error is a Parser which is currently infallible.

If I understand correctly that you are trying to parse a disallowed pattern (such as in Rust .. outside of a struct), then depending on your resulting parse tree, validate may be enough:

    rest_pat
        .validate(|_, e, emitter| {
        emitter.emit(Rich::custom(e.span(), format!("rest pattern is not allowed here")));
        Pattern::Rest // or Pattern::Error
    })

It really depends on what your parse tree supports, and what you are actually wanting to do. Do you want to stop parsing the first time you see a bad pattern or do you want to just error and keep going? Does your parse tree support Error variants? Does it disallow it to keep the tree restricted to only those which are strictly valid?

[BinaryQuantumSoul]

Okay so for example, I want to check that I each string is terminated

none_of('"')
.repeated()
.collect::<String>()
.delimited_by(
  just('"'), 
  just('"').or_not().try_map(|o,e| o.unwrap_or_else(Err(Rich::custom(e.span(), MyError::UnterminatedString)))
)
.recover_with(via_parser(
  none_of('"')
  .delimited_by(
    just('"'), 
    just('"').ignored().or(just('\n').ignored().or(end())))
).map(Lexeme::Error))

The recover_with is required because otherwise when there is an error the already marched input is not given, only the error.

[zesterer]

You probably want .map_err here instead, i.e:

...
    .delimited_by(
      just('"'), 
      just('"').map_err(|_,e| Rich::custom(e.span(), MyError::UnterminatedString))
    )

or, even better, use a label to describe what the expected pattern was: and chumsky will pass it through into the final error:

...
    .delimited_by(
      just('"'), 
      just('"').labelled("string terminator")
    )

which will produce errors like this:

"abcd
     ^ Error: found end of input, expected string terminator

You can even improve things by adding 'context labels':

...
    .delimited_by(
      just('"'), 
      just('"').labelled("string terminator")
    )
    .labelled("string")
    .as_context()

which will produce errors like:

"abcd
^    ^ Error: found end of input, expected string terminator
|
|    ^
`----'- found when parsing this string

Fwiw I think there is a particular pattern in your thinking that might be unhelpful here. Chumsky is about parsing, not validating. It's about building up the positive space of acceptable inputs, not carving away the negative space. That means that you declare what is valid and expected and everything else is rejected by default. In this mindset, the only thing you're looking to do here is layer a bit of information on top of chumsky's existing behaviour to pass down to your end user, and that's exactly what map_err and labelled are for :)

[BinaryQuantumSoul]

Thank you I think I understand more.

How would I do to prevent some characters and report the correct error? For example forbidden \n in a string ?

And is there another way to output already matched input on error than doing a dummy recover parser?