How to add simple context to a Cut error?

[DavidAntliff]

I have found this crate very straightforward to use once I got past the initial learning curve. It's very nicely designed, with great docs and examples. A pleasure to use. Thank you to the author and contributors.

But there's one aspect I'm having trouble with - basic error reporting.

To start, I have a simple floating point subparser function that simply delegates to a built-in one:

fn float(i: &mut &str) -> PResult<f64> {
    winnow::ascii::float.parse_next(i)
}

This works fine, but I discovered in my application that this also parses "nan" and "inf" into their respective values, and I want to catch this at parse time, as a fatal error.

So I changed the function to:

fn float_inner(i: &mut &str) -> PResult<f64> {
    let f: f64 = winnow::ascii::float.parse_next(i)?;

    if f.is_nan() || f.is_infinite() {
        Err(ErrMode::Cut(ContextError::new()))
    } else {
        Ok(f)
    }
}

This halts the parser on "nan", but the error message shown to the user isn't great - it's just "Parse error" with the line and column, and input line, but no explanation.

So I looked to add a context, but to cut a long story short, I just couldn't work out how to add a context to the Err variant. I was not able to find any way to add information to ContextError either. Maybe there is a way, but I haven't found it yet.

In the end, inspired by cut_err(), I did this:

fn float_inner(i: &mut &str) -> PResult<f64> {
    let f: f64 = winnow::ascii::float.parse_next(i)?;
    if f.is_nan() || f.is_infinite() {
        Err(ErrMode::Cut(ContextError::new()))
    } else {
        Ok(f)
    }
}

fn float(i: &mut &str) -> PResult<f64> {
    float_inner
        .context(StrContext::Label("finite float"))
        .parse_next(i)
}

This is because, based on the chapter 7 tutorial, I can see how .context() can be called on anything that implements the Parser trait, but I can't work out how to add context to a PResult. So I need the outer function to give me an inner function to hang .context() on.

I have a similar issue with these sorts of functions:

fn hex_digits(i: &mut &str) -> PResult<u32> {
    let s = take_while(1.., |c: char| c.is_ascii_hexdigit()).parse_next(i)?;
    u32::from_str_radix(s, 16).map_err(|_| ErrMode::Cut(ContextError::new()))  // how to add context here?
}

Do I need to wrap those in an outer/inner parse function as well, just to be able to call .context() on the inner function symbol?

I feel like there must be a simpler way that I'm missing.

I found this discussion: #504 - there's mention of ErrMode::from_external_error(), but there isn't quite enough code there to demystify this for me. Is this what I should be using?

[DavidAntliff]

I explored using ErrMode::from_external_error() and I was able to reduce it to a single function, but I had to define a custom Error type as well:

#[derive(Debug, derive_more::Display, thiserror::Error)]
struct FloatNotFinite {
    msg: &'static str,
}

fn float(i: &mut &str) -> PResult<f64> {
    let f: f64 = winnow::ascii::float.parse_next(i)?;

    if f.is_nan() || f.is_infinite() {
        Err(ErrMode::from_external_error(
            i,
            ErrorKind::Verify,
            FloatNotFinite {
                msg: "Float not finite",
            },
        )
        .cut())
    } else {
        Ok(f)
    }
}

This seems less than ideal just to convey a static &str to the user - is there a better way? (Technically "Float not finite" could be in impl Display for FloatNotFinite, I just wanted to demonstrate the passing of an arbitrary message defined "in-line" back to the user).

[epage]

What about AddContext? That is what Parser::context calls.

[DavidAntliff]

I did see this, and the docs say:

This is used mainly by Parser::context,

But is this true? The code seems to just construct and return a Context<impl Parser, I, O, E, C> value. It's not clear to me how this Context is then added to a PResult.

I don't see a call to AddContext::add_context() in Parser::context. I did try to call AddContext manually on my Err but I couldn't work out what I needed to pass in as _token_start.

[DavidAntliff]

Ok, some progress I think, using add_context() in a single function:

fn float(i: &mut &str) -> PResult<f64> {
    let f: f64 = winnow::ascii::float.parse_next(i)?;
    if !f.is_finite() {
        Err(ErrMode::Cut(ContextError::new()).add_context(
            i,
            &i.checkpoint(),
            winnow::error::StrContext::Label("float"),
        ))
    } else {
        Ok(f)
    }
}

I found one example of this in impl Parser for Context, parse_next() in parser.rs and a mention in the Changelog.

Would this be your recommended approach for such "embedded logic" errors?

[epage]

Yes, if directly constructing an error, rather than building on top of an existing error, this is the way to do it.

Ideally, you could do winnow::ascii::float.verify(|f| f.is_finite()).context(...) but then the context would apply to failures from winnow::ascii::float and when you only want it to apply to verify. #180 is the issue for this and I just don't have a good answer beyond writing imperative code like this.

[DavidAntliff]

Ok, I think I have enough to move forward - thank you for your advice and time.