Jengamon/magus - Change YOZBOIICKWWMCBXLBSQBACSKM6I4APCXRVOLFP7B46TXXHKBJRWQC

feat: add decimal lex/parse

Created by Jengamon on February 28, 2024

YOZBOIICKWWMCBXLBSQBACSKM6I4APCXRVOLFP7B46TXXHKBJRWQC

Dependencies

In channels

main

Change contents

Replacement in magus_core/src/lib.rs at line 7 [4.2078]
B:BD[3.894] → [3.894:927]
```
    use std::num::ParseIntError;
```
[3.894]
[3.927]
```
    use std::num::{ParseFloatError, ParseIntError};
```

Insertion in magus_core/src/lib.rs at line 147 [4.2078]

[5.1599]

    }
    #[derive(thiserror::Error, Debug)]
    pub enum DecimalParseError {
        #[error(transparent)]
        FloatError(#[from] ParseFloatError),
        #[error(transparent)]
        IntError(#[from] ParseIntError),

Replacement in magus_core/src/lib.rs at line 157 [4.2078]

∅:D[5.1606] → [3.4742:4798]

B:BD[3.4742] → [3.4742:4798]

    #[derive(Debug, Clone, PartialEq, Eq, Hash, Logos)]

[5.1606]

[3.4798]

    fn decimal_number_parser(input: &mut &str) -> PResult<(f64, i32)> {
        let sign = || opt(one_of(['-', '+']));
        let digits_with_underscores = || {
            repeat(1.., alt((digit1.map(Some), '_'.map(|_| None))))
                .map(|vd: Vec<Option<&str>>| vd.into_iter().flatten().collect::<Vec<_>>().join(""))
        };
        let float_digits = || {
            (
                opt(digits_with_underscores()),
                '.',
                digits_with_underscores(),
            )
                .map(|(maybe_predot, _, postdot)| {
                    maybe_predot
                        .map(|predot| format!("{predot}.{postdot}"))
                        .unwrap_or_else(|| format!(".{postdot}"))
                })
        };
        let signed_base = (sign(), alt((float_digits(), digits_with_underscores()))).map(
            |(sign, digits): (_, String)| {
                if let Some(sign) = sign {
                    format!("{sign}{digits}")
                } else {
                    digits
                }
            },
        );
        let exponent = preceded("e", (sign(), digits_with_underscores()));
        (signed_base, opt(exponent))
            .try_map(|(base, maybe_exp)| {
                let base = base.parse::<f64>()?;
                let exponent = if let Some((sign, exponent)) = maybe_exp {
                    let signed = if let Some(sign) = sign {
                        format!("{sign}{exponent}")
                    } else {
                        exponent
                    };
                    signed.parse::<i32>()?
                } else {
                    0
                };
                Ok::<_, DecimalParseError>((base, exponent))
            })
            .parse_next(input)
    }
    fn parse_float(lexer: &mut Lexer<Token>) -> Result<(f64, i32), LexError> {
        let target = lexer.slice();
        decimal_number_parser.parse(target).map_err(|e| {
            // TODO A proper lex error
            dbg!(std::any::type_name_of_val(&e));
            LexError::Unknown
        })
    }
    #[derive(Debug, Clone, PartialEq, Logos)]

Replacement in magus_core/src/lib.rs at line 233 [4.2078]

∅:D[2.242] → [3.5533:5749]

∅:D[5.1784] → [3.5533:5749]

B:BD[3.5533] → [3.5533:5749]

B:BD[3.5749] → [5.1785:1855]

∅:D[5.1855] → [3.5749:5766]

B:BD[3.5749] → [3.5749:5766]

        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9]?[0-9_]*")]
        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9]?[0-9_]*e[+-]?[0-9_]+")]
        #[regex(r"[+-]?\.[0-9][0-9_]*")]
        #[regex(r"[+-]?\.[0-9][0-9_]*e[+-]?[0-9_]+")]
        #[regex(r"[+-]?[0-9][0-9_]*e\-[0-9_]+")] // Negative exponent
        Decimal,

[2.242]

[3.5766]

        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9][0-9_]*", parse_float)]
        #[regex(r"[+-]?[0-9][0-9_]*\.[0-9][0-9_]*e[+-]?[0-9_]+", parse_float)]
        #[regex(r"[+-]?\.[0-9][0-9_]*", parse_float)]
        #[regex(r"[+-]?\.[0-9][0-9_]*e[+-]?[0-9_]+", parse_float)]
        #[regex(r"[+-]?[0-9][0-9_]*e\-[0-9_]+", parse_float)] // Negative exponent
        Decimal((f64, i32)),