Question about alt

[echoptic]

Im writing a Lua parser and I want it to first try parsing integers, then floats. When the integer parser fails, I want it to try the float parser too, but its failing on any float input (1., 0x1.0, ...). Im not sure why its not trying other parsers.

fn numeric_literal<'a>(input: &mut Input<'a>) -> PResult<NumericLiteral> {
    let hex_int = preceded(
        tag_no_case("0x"),
        hex_digit1.try_map(|s| i64::from_str_radix(s, 16)),
    );
    let hex_exponent = preceded(tag_no_case("p"), (opt(one_of(['+', '-'])), digit1));
    let hex_float = preceded(
        tag_no_case("0x"),
        (
            alt((
                ('.', hex_digit1).recognize(),
                (hex_digit1, opt(preceded('.', opt(hex_digit1)))).recognize(),
            )),
            opt(hex_exponent),
        ),
    )
    .map(|(num, exponent): (&str, Option<(Option<char>, &str)>)| {
        let mut result;
        if let Some((int, frac)) = num.split_once('.') {
            result = i64::from_str_radix(int, 16).unwrap() as f64;
            if let Ok(frac_val) = u64::from_str_radix(frac, 16) {
                result += (frac_val / 16u64.pow(frac.len() as u32)) as f64;
            }
        } else {
            result = u64::from_str_radix(num, 16).unwrap() as f64;
        }

        if let Some((sign, exponent)) = exponent {
            let exponent = 2u64.pow(exponent.parse::<u32>().unwrap()) as f64;
            match sign.unwrap_or_default() {
                '-' => result /= exponent,
                _ => result *= exponent,
            }
        }

        return result;
    });

    alt((
        hex_int.map(NumericLiteral::Integer),
        digit1.parse_to().map(NumericLiteral::Integer),
        hex_float.map(NumericLiteral::Float),
        float.map(NumericLiteral::Float),
    ))
    .parse_next(input)
}

[epage]

Likely it would help if you included relevant tests showing the failure and where the Input is at the time of the failure.

You likely also want to run one of the tests with --features winnow/debug as that will walk you through how each parser is applied. You can add your own context with the trace combinator.

My best guess is that the integer parser matches and then leaves &mut Input at the . and the next parser then tries to read that and fails. To fix this, you can instead try the float parser first, requiring the ., or you can capture up to a delimiter and then parse the returned slice.

[echoptic]

This is an unrelated question, but im not sure how would i parse some things in lua grammar since they are recursively calling eachother, specifically this part:

functioncall ::=  prefixexp args | prefixexp ‘:’ Name args 
var ::=  Name | prefixexp ‘[’ exp ‘]’ | prefixexp ‘.’ Name 
prefixexp ::= var | functioncall | ‘(’ exp ‘)’

Whole grammar can be found here but its not necessary for this: https://www.lua.org/manual/5.4/manual.html#9
Can you give me some help about how can I approach this.

[epage]

Not quite sure what part of a recursive grammar is giving you problems. Maybe looking at the json parser can give you some ideas since a Value can contain an Array or an Object which contains Values.

[echoptic]

After looking at the output of -F winnow/debug I was able to find the problems. It was related to matching up to the . like you mentioned.