Help with annotating space1 in tuple parser

[mzagrabe]

Hello,

I'm getting started with winnow and have a question.

This works for parsing:

use winnow::Parser;
use winnow::PResult;
use winnow::ascii::digit1;
use winnow::ascii::space1;

fn parse_digits<'s>(input: &mut &'s str) -> PResult<&'s str> {
    digit1.parse_next(input)
}

fn main() {
    let mut input = "Game 10: foo";
    let foo = ( 
        "Game",
        space1,
        parse_digits,
    ).parse_next(&mut input).unwrap();

    println!("{foo:?}");
}

but this:

use winnow::Parser;
use winnow::ascii::space1;

fn main() {
    let mut input = "Game 10: foo";
    let foo = (
        "Game",
        space1,
    ).parse_next(&mut input).unwrap();

    println!("{foo:?}");
}

emits an error and I'm not sure how best to proceed:

   Compiling winnow-test v0.1.0 (/tmp/winnow-test)
error[E0283]: type annotations needed
   --> src/main.rs:8:9
    |
8   |         space1,
    |         ^^^^^^ cannot infer type of the type parameter `E` declared on the function `space1`
    |
    = note: multiple `impl`s satisfying `_: ParserError<&str>` found in the `winnow` crate:
            - impl<I, C> ParserError<I> for ContextError<C>;
            - impl<I, C> ParserError<I> for TreeError<I, C>
              where I: Clone;
            - impl<I, C> ParserError<I> for VerboseError<I, C>
              where I: Clone;
            - impl<I, E> ParserError<I> for ErrMode<E>
              where E: ParserError<I>;
            - impl<I> ParserError<I> for ();
            - impl<I> ParserError<I> for InputError<I>
              where I: Clone;
            - impl<I> ParserError<I> for winnow::error::ErrorKind;
note: required by a bound in `space1`
   --> /home/z/.cargo/registry/src/index.crates.io-6f17d22bba15001f/winnow-0.5.30/src/ascii/mod.rs:794:21
    |
794 | pub fn space1<I, E: ParserError<I>>(input: &mut I) -> PResult<<I as Stream>::Slice, E>
    |                     ^^^^^^^^^^^^^^ required by this bound in `space1`
help: consider specifying the generic arguments
    |
8   |         space1::<&str, E>,
    |               +++++++++++

error[E0283]: type annotations needed
 --> src/main.rs:8:9
  |
8 |         space1,
  |         ^^^^^^ cannot infer type of the type parameter `E` declared on the function `space1`
9 |     ).parse_next(&mut input).unwrap();
  |       ---------- ---------- type must be known at this point
  |       |
  |       required by a bound introduced by this call
  |
  = note: multiple `impl`s satisfying `_: ParserError<&str>` found in the `winnow` crate:
          - impl<I, C> ParserError<I> for ContextError<C>;
          - impl<I, C> ParserError<I> for TreeError<I, C>
            where I: Clone;
          - impl<I, C> ParserError<I> for VerboseError<I, C>
            where I: Clone;
          - impl<I, E> ParserError<I> for ErrMode<E>
            where E: ParserError<I>;
          - impl<I> ParserError<I> for ();
          - impl<I> ParserError<I> for InputError<I>
            where I: Clone;
          - impl<I> ParserError<I> for winnow::error::ErrorKind;
  = note: required for `(&'static str, for<'a> fn(&'a mut &str) -> Result<<&str as Stream>::Slice, ErrMode<_>> {space1::<&str, _>})` to implement `Parser<&str, (&str, &str), _>`
help: consider specifying the generic arguments
  |
8 |         space1::<&str, E>,
  |               +++++++++++

For more information about this error, try `rustc --explain E0283`.
error: could not compile `winnow-test` (bin "winnow-test") due to 2 previous errors

I see the compiler message to annotate the call to space1, but I'm not quite sure how to do that.

What do folks think about my problem?

Thanks for any help!

-m

[epage]

PResult is a type alias for Result with a default parameter for E so when you declare parse_digits, you are specifying an E implicitly. Since the tuple has to all have the same E, this lets Rust infer E for the other parsers which are generic.

What to do depends on what kind of error reporting you want. If you want the same error type as above, you could do

use winnow::Parser;
use winnow::ascii::space1;

fn main() {
    let mut input = "Game 10: foo";
    let foo = (
        "Game",
        space1::<_, winnow::error::ContextError>,
    ).parse_next(&mut input).unwrap();

    println!("{foo:?}");
}

Tips

• Putting your top-level parser in a function provides an easier / cleaner way of specifying types than using the turbofish (and makes it easier to test)
• If this is the top-level parser for parsing a string thats all in-memory, I'd recommend using parse, rather than parse_next
• I generally name parsers for their role in the grammar and leave off parse_ prefixes since parse_next till take care of that

[mzagrabe]

Thanks @epage for the help!