Newbie Question: parse a 4 digit year?

[cmbothwell]

Running the following code:

use chumsky::prelude::*;

#[derive(Debug)]
enum Decl {
    Year(u64),
}

fn parser() -> impl Parser<char, Decl, Error = Simple<char>> {
    let digits = text::digits::<_, Simple<char>>(10);
    let year = digits.repeated().exactly(4);

    year.then_ignore(end()).map(|c| Decl::Year(0000))
}

fn main() {
    let src = std::fs::read_to_string(std::env::args().nth(1).unwrap()).unwrap();

    match parser().parse(src) {
        Ok(ast) => println!("{:?}", ast),
        Err(parse_errs) => parse_errs
            .into_iter()
            .for_each(|e| println!("Parse error: {}", e)),
    }
}

produces the following output: Parse error: found end of input when run on a file containing 1999 (and nothing else).

It's my understanding that the then_ignore(end()) sets me up to handle the end of the file, so I'm not sure why I'm getting this error. I'm sure I'm making a very beginner mistake. Thanks a lot in advance for your time.

[Zij-IT]

My assumption is that your file contains a newline. You can test this by just trying to parse the string "1999".

If you want to ignore whitespace, add .padded()

Edit: Actually, which version of Chumsky are you using? I think it’s 0.9, but I’m not 100%. If you are on the 1.0.x, lazy-per-default with parse was removed.

[cmbothwell]

Hello,

Thanks for your reply. I am on version chumsky = "0.9.3".

Adding .padded() didn't seem to fix the issue:

use chumsky::prelude::*;

#[derive(Debug)]
enum Decl {
    Year(u64),
}

fn parser() -> impl Parser<char, Decl, Error = Simple<char>> {
    let digits = text::digits::<_, Simple<char>>(10);
    let year = digits.repeated().exactly(4);

    year.padded().then_ignore(end()).map(|c| Decl::Year(0000))
}

fn main() {
    let src = std::fs::read_to_string(std::env::args().nth(1).unwrap()).unwrap();

    match parser().parse(src) {
        Ok(ast) => println!("{:?}", ast),
        Err(parse_errs) => parse_errs
            .into_iter()
            .for_each(|e| println!("Parse error: {}", e)),
    }
}

Running the above via cargo run -- ./files/test.txt where ./files/test.txt contains the content 9999 produces the output: Parse error: found end of input

Removing the .exactly(4) call and re-running causes the parse to succeed.

Thanks so much for your time.

[zesterer]

digits parses as many digits as it can in one go: so the very first time it's invoked, it's consuming every digit and then the remaining 3 attemts at consuming digits have nothing left to consume, hence 'found end of input'. Consider using the following instead:

filter(char::is_digit).repeated().exactly(4)

[cmbothwell]

Thanks! The following works:

use chumsky::prelude::*;

#[derive(Debug)]
enum Decl {
    Year(u64),
}

fn parser() -> impl Parser<char, Decl, Error = Simple<char>> {
    let year = filter(|c: &char| c.is_digit(10))
        .repeated()
        .exactly(4)
        .map(|c| Decl::Year(2000));

    year.padded().then_ignore(end()).map(|c| c)
}

fn main() {
    let src = std::fs::read_to_string(std::env::args().nth(1).unwrap()).unwrap();

    match parser().parse(src) {
        Ok(ast) => println!("{:?}", ast),
        Err(parse_errs) => parse_errs
            .into_iter()
            .for_each(|e| println!("Parse error: {}", e)),
    }
}