Don't understand grammar

[qknight]

Describe the bug

On the webpage editor at https://pest.rs/ I enter this:

D = _{ ASCII_DIGIT+ }
D3 = _{ ASCII_DIGIT{3} }
D13 = _{ ASCII_DIGIT{1,3} }
L = _{ D13 ~ ("," ~ D3)* }
R = _{ (ASCII_DIGIT{3} ~ ",")* ~ D13 }    
Q = _{ D ~ "." ~ D }
us_number = ${ 
    "." ~ D | Q |
    L ~ D13 | L | L ~ "." | 
    D13 ~ D3 |
    L ~ "." ~ R | 
    "." ~ R | D ~ "." | D
}

And as number:

3122345132

And the decoded us_number is: "312234" instead of "3122345132".

This happens due to the rule D13 ~ D3 but the documentation says PEST is greedy and this is, I think, lazy matching.

If I move the | D from the grammar to the first place it parses the number correctly as: 3122345132.

Why?

To Reproduce
Simply paste the grammar from above and the input value and set decode as to 'us_number' on the webpage!

Expected behavior
I expect it to decode as 3122345132 instead of "312234" no matter if the grammar reads | D at the end or D | at the beginning.

Additional context

I want to write a parser for US and DE float numbers, here are two tests in order to better explain my goal:

#[test]
fn edge_defined_de_floats_DE() {
    let floats = vec![
        "1",
        "1,",
        "1,",
        "2,",
        "1,0",
        "1,000",
        "1,0000",
        "0,5",
        "10,00",
        "1.000",
        "1.000,00",
        "1.000,1",
        "1.200,000",
        "100.000,23",
        "1,0000",
        "0,0001",
        "2.345,67",
        "1.234.567,89",
        "1.000.000,000",
        "10.000,0001",
        "1,2345",
        "0,000001",
        "999,999"
    ];
    for f in floats {
        let input = format!("\"a\" {f} \"a\"");
        let output = parse_emission(&input, NumberFormat::DE).unwrap();
        let normalized = f.replace('.', "").replace(',', ".");
        // println!("{f} - normalized: {normalized}");
        let v = normalized.parse::<f64>().unwrap();
        let q: Vec<Emission> = vec![EdgeDefined(1, "a".to_string(), v, "a".to_string())];
        assert_eq!(output.as_slice(), q.as_slice());
    }
}

#[test]
fn edge_defined_de_floats_US() {
    let floats = vec![
        "1",
        "1.",
        "1.",
        "2.",
        "1.0",
        "1.000",
        "1.0000",
        "0.5",
        "10.00",
        "1.000",
        "1,000.00",
        "1,000.1",
        "1,200.000",
        "100,000.23",
        "1.0000",
        "0.0001",
        "2,345.67",
        "1,234.567.89",
        "1,000,000.000",
        "10,000.0001",
        "1.2345",
        "0.000001",
        "999.999"
    ];
    for f in floats {
        let input = format!("input: \"a\" {f} \"a\"");
        let output = parse_emission(&input, NumberFormat::US).unwrap();
        let normalized = f.replace(',', "").replace('.', ",");
        println!("{f} - normalized: {normalized}");
        let v = normalized.parse::<f64>().unwrap();
        let q: Vec<Emission> = vec![EdgeDefined(1, "a".to_string(), v, "a".to_string())];
        assert_eq!(output.as_slice(), q.as_slice());
    }
}

[HoloTheDrunk]

Hello, as per the pest book, the pipe | operator is an ordered choice.
Removing the silencing from your rules helps to see what's happening:

- us_number
  - L > D13: "312"
  - D13: "234"

The L ~ D13 sequence parses correctly so the entire ordered choice collapses into its result, in this case 6 numbers in a row.

[qknight]

Maybe someone else has the same problem as i did, here is how i solved it:

After days trying to get this grammar into PEST/PEG/CHMOSKY I ended up in using a regexp since for me it is easier to create meaningful error messages for my users. I would have wished to use PEST but couldn't solve simple things as the ^ and $ in the regexp do now. Not saying PEST or the others are bad, but simply too complicated for my use-case.

#[allow(unused)]
#[derive(Debug, Clone, Copy)]
pub enum NumberFormat {
    DE,
    US,
}

impl NumberFormat {
    fn parse_number(&self, num_str: &str) -> Result<f64, std::num::ParseFloatError> {
        match self {
            NumberFormat::DE => {
                //println!("DE");
                let normalized = num_str.replace('.', "").replace(',', ".");
                normalized.parse::<f64>()
            }
            NumberFormat::US => {
                //println!("US");
                let normalized = num_str.replace(',', "");
                normalized.parse::<f64>()
            }
        }
    }
}

pub fn parse_line(
    line_number: usize,
    line: &str,
    number_format: NumberFormat,
) -> Result<Option<PestEmission>, String> {
    let optional_regexp = Regex::new(
        r#"^\s*"(?P<source>[^"]+)"\s*(?P<value>[\d.,]+)?\s*(?:"(?P<target>[^"]+)")\s*$"#,
    )
    .unwrap();
    let Some(captures) = optional_regexp.captures(line) else {
        if line.trim().is_empty() {
            return Ok(None);
        }
        return Err(format!(
            "Line \"{}\" does not match expected format, which must be: [\"ID\" \"ID\"] | [\"ID\" NUM \"ID\"]",
            line_number
        ));
    };
    let Some(value) = captures.name("value") else {
        return Ok(Some(PestEmission::EdgeUndefined(EdgeUndefined {
            line: line_number,
            source: captures["source"].to_string(),
            target: captures["target"].to_string(),
        })));
    };
    let number = match number_format.parse_number(value.as_str()) {
        Ok(number) => number,
        Err(e) => {
            return Err(format!(
                "The number \"{}\" on line \"{}\" does not match expected format: {}",
                value.as_str(), line_number, e // FIXME error contains label
            ));
        }
    };
    Ok(Some(PestEmission::EdgeDefined(EdgeDefined {
        line: line_number,
        source: captures["source"].to_string(),
        target: captures["target"].to_string(),
        value: number,
    })))
}

[HoloTheDrunk]

Regexp ^ and $ are SOI and EOI in Pest according to the book.
For future simple parsing needs you might want to take a look at the nom crate.