xod 1.0.1

A tiny REPL for bitwise arithmetic and expression evaluation.
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
113
114
115
116
117
118
119

use super::Span;
use nom::{
    IResult, Parser,
    bytes::complete::tag,
    character::streaming::multispace0,
    sequence::{delimited, preceded, terminated},
};

pub fn space_around<'a, P, O>(
    input: P,
) -> impl Parser<Span<'a>, Output = O, Error = nom::error::Error<Span<'a>>>
where
    P: Parser<Span<'a>, Output = O, Error = nom::error::Error<Span<'a>>>,
{
    delimited(opt_multispace0, input, opt_multispace0)
}

pub fn opt_multispace0(input: Span) -> IResult<Span, ()> {
    let input = match (multispace0).parse_complete(input) {
        Ok((input, _)) => input,
        Err(e) => match e {
            nom::Err::Incomplete(_) => input,
            nom::Err::Error(_) => input,
            nom::Err::Failure(_) => return Err(e),
        },
    };
    Ok((input, ()))
}

#[inline(always)]
pub fn open_bracket(input: Span) -> IResult<Span, Span> {
    terminated(tag("["), opt_multispace0).parse_complete(input)
}

#[inline(always)]
pub fn close_bracket(input: Span) -> IResult<Span, Span> {
    preceded(opt_multispace0, tag("]")).parse_complete(input)
}

#[inline(always)]
pub fn open_paren(input: Span) -> IResult<Span, Span> {
    terminated(tag("("), opt_multispace0).parse_complete(input)
}

#[inline(always)]
pub fn close_paren(input: Span) -> IResult<Span, Span> {
    preceded(opt_multispace0, tag(")")).parse_complete(input)
}

#[inline(always)]
pub fn open_brace(input: Span) -> IResult<Span, Span> {
    space_around(tag("{")).parse_complete(input)
}

#[inline(always)]
pub fn close_brace(input: Span) -> IResult<Span, Span> {
    space_around(tag("}")).parse_complete(input)
}

#[inline(always)]
pub fn comma(input: Span) -> IResult<Span, Span> {
    terminated(tag(","), opt_multispace0).parse_complete(input)
}

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

    #[test]
    fn test_brackets() {
        let input = Span::new("[ ]");
        let result1 = (open_bracket).parse_complete(input);
        eprintln!("{:?}", result1);
        assert!(result1.is_ok());
        let (input, result1) = result1.unwrap();
        let result2 = (close_bracket).parse_complete(input);
        eprintln!("{:?}", result2);
        assert!(result2.is_ok());
        let (_, result2) = result2.unwrap();
        unsafe {
            assert_eq!(result1, Span::new_from_raw_offset(0, 1, "[", ()));
            assert_eq!(result2, Span::new_from_raw_offset(2, 1, "]", ()))
        }
    }

    #[test]
    fn test_braces() {
        let input = Span::new("{ }");
        let result1 = (open_brace).parse_complete(input);
        eprintln!("{:?}", result1);
        assert!(result1.is_ok());
        let (input, result1) = result1.unwrap();
        let result2 = (close_brace).parse_complete(input);
        eprintln!("{:?}", result2);
        assert!(result2.is_ok());
        let (_, result2) = result2.unwrap();
        unsafe {
            assert_eq!(result1, Span::new_from_raw_offset(0, 1, "{", ()));
            assert_eq!(result2, Span::new_from_raw_offset(2, 1, "}", ()))
        }
    }

    #[test]
    fn test_parentheses() {
        let input = Span::new("( )");
        let result1 = (open_paren).parse_complete(input);
        eprintln!("{:?}", result1);
        assert!(result1.is_ok());
        let (input, result1) = result1.unwrap();
        let result2 = (close_paren).parse_complete(input);
        eprintln!("{:?}", result2);
        assert!(result2.is_ok());
        let (_, result2) = result2.unwrap();
        unsafe {
            assert_eq!(result1, Span::new_from_raw_offset(0, 1, "(", ()));
            assert_eq!(result2, Span::new_from_raw_offset(2, 1, ")", ()))
        }
    }
}