Make choice report full names instead of first letters

[soywod]

I tried to set up ariadne based on your JSON example, and it works like a charm. I just have a small question regarding the precision of the diagnostic. I have the following parser:

pub(crate) fn single_part<'a>() -> impl Parser<'a, &'a str, Part, extra::Err<Rich<'a, char>>> + Clone
{
    just(SINGLE_PART_BEGIN)
        .ignore_then(
            choice((
                part_type(),
                name(),
                disposition(),
                #[cfg(feature = "pgp")]
                encrypt(),
                #[cfg(feature = "pgp")]
                sign(),
            ))
            .repeated()
            .collect::<HashMap<_, _>>()
            .then_ignore(just(GREATER_THAN))
            .then_ignore(just(NEW_LINE).or_not()),
        )
        .then(text_plain_part())
        .then_ignore(just(SINGLE_PART_END).then(just(NEW_LINE).or_not()).or_not())
        .map(|(props, content)| Part::SinglePart(props, content))
}

When I try to parse an invalid prop like: <#part bad=prop> I have the following error:

Error: cannot parse MML message
   ╭─[<unknown>:3:8]
   │
 3 │ <#part bad=prop>
   │        ┬  
   │        ╰── found 'b' expected 't', 'f', 'n', or 'd'
───╯

Is there by any chance a way to ask the parser to show full names type, filename, name or description instead of first letters?

[Zij-IT]

How are name and co. defined?

[soywod]

They are really simple, they are structured the same way (key=val):

pub(crate) fn name<'a>() -> impl Parser<'a, &'a str, Prop, extra::Err<Rich<'a, char>>> + Clone {
    just(NAME)
        .then_ignore(just('=').padded())
        .then(choice((quoted_val(), val())))
        .padded()
        .map(|(key, val)| (key.to_string(), val.to_string()))
}

[zesterer]

This is a product of the fact that just works on the level of tokens (in your case, chars), even when given a sequence (like "foo"). Chumsky provides a way to 'realias' a parser in error messages: the .labelled(...) combinator (on 1.0, you'll need to enable the label feature). Now you can do this:

just("foo")
    .labelled("foo")

And you'll get something like this in the error message:

found 'b', expected 'foo'

labelled works on all parsers, even much more complex ones. This allows you to realias an entire pattern (such as 'expressions') and have something like found '#', expected expression appear in your error message. For example, the nano_rust example uses this to produce easier to understand errors.

[soywod]

It is exactly what I needed, thanks a lot for your help! And thank you for the great tools, I really love the API 👌