kamo 0.2.0

A library to assist in the creation of an interpreter or compiler and its associated runtime.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::parser::{code, prelude::*, Input, ParseError, ParseResult};

use super::{LiteralError, Radix};

/// Recognizes a natural number literal with an optional sign `'+'` and the
/// given radix.
/// 
/// # Grammar:
/// 
/// The grammar does not include a prefix for the radix. This is because the
/// radix is already known when parsing the natural literal. You must implement
/// the prefix yourself.
/// 
/// The rules for `<Digit R>` are generic over `R` which expands to the radix
/// of the natural literal.
/// 
/// ```text
/// Natural     = Sign? <Digit R>+
/// Sign        = '+'
/// <Digit 2>   = [0-1]
/// <Digit 8>   = [0-7]
/// <Digit 10>  = [0-9]
/// <Digit 16>  = [0-9A-Fa-f]
///
/// R = 2 | 8 | 10 | 16
/// ```
pub fn recognize_natural(radix: Radix) -> impl for<'a> Fn(Input<'a>) -> ParseResult<'a, &'a str> {
    move |input| {
        recognize(tuple((opt(char('+')), radix.digit1())))(input).map_err(|mut err| {
            err.push(input, code::ERR_NATURAL_FORMAT, LiteralError::NaturalFormat);
            err
        })
    }
}

/// Parses a natural number literal with an optional sign `'+'` and the given
/// radix.
/// 
/// The grammar is the same as the one for `recognize_natural` except that it
/// parses the value instead of recognizing it. Returns the value as a `u64`.
/// 
/// The grammar does not include a prefix for the radix. This is because the
/// radix is already known when parsing the natural literal. You must implement
/// the prefix yourself.
pub fn natural(radix: Radix) -> impl for<'a> Fn(Input<'a>) -> ParseResult<'a, u64> {
    move |input| {
        let (output, input) = recognize_natural(radix)(input)?;
        let value = u64::from_str_radix(output, radix.base())
            .map_err(|_| ParseError::new(input, code::ERR_NATURAL, LiteralError::Natural))?;
        Ok((value, input))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const NATURALS: [(&str, Radix); 28] = [
        ("0", Radix::Binary),
        ("0", Radix::Octal),
        ("0", Radix::Decimal),
        ("0", Radix::Hexadecimal),
        ("1", Radix::Binary),
        ("1", Radix::Octal),
        ("1", Radix::Decimal),
        ("1", Radix::Hexadecimal),
        ("0101010", Radix::Binary),
        ("01234567", Radix::Octal),
        ("0123456789", Radix::Decimal),
        ("0123456789", Radix::Hexadecimal),
        ("abcdef", Radix::Hexadecimal),
        ("ABCDEF", Radix::Hexadecimal),
        ("+0", Radix::Binary),
        ("+0", Radix::Octal),
        ("+0", Radix::Decimal),
        ("+0", Radix::Hexadecimal),
        ("+1", Radix::Binary),
        ("+1", Radix::Octal),
        ("+1", Radix::Decimal),
        ("+1", Radix::Hexadecimal),
        ("+0101010", Radix::Binary),
        ("+01234567", Radix::Octal),
        ("+0123456789", Radix::Decimal),
        ("+0123456789", Radix::Hexadecimal),
        ("+abcdef", Radix::Hexadecimal),
        ("+ABCDEF", Radix::Hexadecimal),
    ];

    #[test]
    fn recognize_natural_success() {
        for (value, radix) in NATURALS.iter() {
            let input = Input::new(value);
            let result = recognize_natural(*radix)(input);
            assert_eq!(result, Ok((*value, Input::new(""))));
        }
    }

    #[test]
    fn natural_success() {
        for (value, radix) in NATURALS.iter() {
            let input = Input::new(value);
            let result = natural(*radix)(input);
            assert_eq!(
                result,
                Ok((
                    u64::from_str_radix(value, radix.base()).unwrap(),
                    Input::new("")
                ))
            );
        }
    }
}