Compatibility with VerboseError

[perlindgren]

Hi fflorent and others.

Is there some example how to use nom_locate with the VerboseError type.

I tried changing the example.

fn parse_foobar(s: Span) -> IResult<Span, Token, VerboseError<&str>> {
    let (s, _) = take_until("foo")(s)?;
    let (s, pos) = position(s)?;
    let (s, foo) = tag("foo")(s)?;
    let (s, bar) = tag("baz")(s)?;

    Ok((
        s,
        Token {
            position: pos,
            foo: foo.fragment,
            bar: bar.fragment,
        },
    ))
}

fn parse_foobar(s: Span) -> IResult<Span, Token, VerboseError<&Span>> {
    let (s, _) = take_until("foo")(s)?;
    let (s, pos) = position(s)?;
    let (s, foo) = tag("foo")(s)?;
    let (s, bar) = tag("baz")(s)?; // just to trigger the error

    Ok((
        s,
        Token {
            position: pos,
            foo: foo.fragment,
            bar: bar.fragment,
        },
    ))
}

as well as:

fn parse_foobar(s: Span) -> IResult<Span, Token, VerboseError<&Span>> {
     ...
}

(The latter perhaps makes no sense...).

In both cases I end up with missing trait implementations, so I wonder if I made some stupid mistake, or that there is a compatibility issue?

(By the way, I use the latest released versions of both nom and nom_locate.)

Best regards
Per

[progval]

Hi,

I didn't use verbose errors with nom 5 yet, but it looks like this is not related to nom_locate. Individual parser functions are not supposed to override the error type, it's chosen by the caller of the parsers, which will generate specialized code for all the parser functions. See https://github.com/Geal/nom/blob/master/doc/error_management.md

[Lythenas]

I'm using:

pub type Input<'i> = LocatedSpanEx<&'i str, ()>;
pub type PResult<'i, O> = IResult<Input<'i>, O, VerboseError<Input<'i>>>;

and this works for writing parsers. But I can't use the convert_error function of nom because that only accepts &str. I'm not sure if this can be generalized in nom or if this library needs its own convert_error.

[progval]

Indeed. I wonder why nom implemented it only for &str instead of ToStr or something. ping @Geal

[sunjay]

Could a new version of this crate be released? 7eb8155 fixes this issue but it's only on master, not on crates.io yet.

[kaj]

v2.0.0 is released since the previous comment. Maybe this issue can be closed?

[chipsenkbeil]

To my knowledge, convert_error is still only for &str, which means it cannot be used with a span. There's an open PR for nom to enable AsStr support: rust-bakery/nom#1050 Separately, there was an issue opened for just this scenario, but didn't receive a response: rust-bakery/nom#1149

[Geal]

hello, I just change convert_error to require Deref<Target=str> on the input type, that should be easy enough to support with nom_locate?

[Geal]

although I think a different approach would be needed, since convert_error wants to count lines, while nom_locate already provides the position

[simon-bourne]

This still isn't working as LocatedSpan<T, X> is Deref<Target = T>, so LocatedSpan<&str> is Deref<Target=&str> (note that target is an &str, not a str). As a workaround, I'm successfully using:

let errors = e
    .errors
    .into_iter()
    .map(|(input, error)| (*input.fragment(), error))
    .collect();

convert_error(input.as_str(), VerboseError { errors })

[rassvet-ii]

Hello. I also tried to use convert_error and LocatedSpan together and failed.
How about this?

impl<T: Deref, X> Deref for LocatedSpan<T, X> {
    type Target = <T as Deref>::Target;
    fn deref(&self) -> &Self::Target {
        &self.fragment.deref()
    }
}

I haven't thought it through, but it should work. I'll try it in my code after this.

PS: I tried it, but it makes the code less cleanly written. I had to rewrite my code where I used *span to get &str with &*span or span.fragment().

[toddATavail]

I couldn't get @simon-bourne's exact workaround to work, probably because of library version or Rust stable vs. nightly, but I can confirm that the following very small tweak works on Rust stable:

# Cargo.toml, for context
[dependencies]
nom = "8.0.0"
nom-language = "0.1.0"
nom_locate = "5.0.0"

let errors = e
	.errors
	.into_iter()
	.map(|(input, error)| (*input.fragment(), error))
	.collect();
// Same as @simon-bourne's code, but `*input` instead of `input.as_str()`.
convert_error(*input, VerboseError { errors })