jpar 0.1.0

A text-oriented, zero-copy, parser combinators library
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
120
121
122
123
124

pub use alternatives::*;

#[cfg(feature = "alloc")]
use crate::parsers::helpers::map_result;
use crate::parsers::helpers::not_found_restore;
use crate::result::{ParserResult, ParserResultError};
use crate::Reader;

mod alternatives;

/// Executes the `condition` parser and if it match, discards its value and parses `then`.
pub fn branch_if<'a, Cond, Then, C, R, Rc, Err>(
    mut condition: Cond,
    mut then: Then,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<Option<R>, Err>
where
    Cond: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<Rc, Err>,
    Then: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
{
    not_found_restore(move |reader| match condition(reader) {
        Ok(_) => Ok(Some(then(reader)?)),
        Err(ParserResultError::NotFound) => Ok(None),
        Err(e) => Err(e),
    })
}

/// Executes the `condition` parser. If it matches, discards its value and parses `then`, otherwise parses `else`.
pub fn branch_if_else<'a, Cond, Then, Else, C, R, Rc, Err>(
    mut condition: Cond,
    mut then: Then,
    mut else_parser: Else,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>
where
    Cond: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<Rc, Err>,
    Then: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
    Else: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
{
    not_found_restore(move |reader| match condition(reader) {
        Ok(_) => then(reader),
        Err(ParserResultError::NotFound) => else_parser(reader),
        Err(e) => Err(e),
    })
}

/// Executes the `then` parser while `condition` matches. This method discards `condition` results.
#[cfg(feature = "alloc")]
pub fn branch_while<'a, Cond, Then, C, Rc, R, Err>(
    condition: Cond,
    then: Then,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<Vec<R>, Err>
where
    Cond: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<Rc, Err>,
    Then: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
{
    crate::parsers::sequence::repeat(
        ..,
        map_result(
            crate::parsers::sequence::tuple((condition, then)),
            |(_, v)| v,
        ),
    )
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

#[cfg(test)]
mod test {
    use crate::parsers::characters::read_text;

    use super::*;

    #[test]
    fn test_branch_if() {
        let mut reader = Reader::new("This is a test");
        let mut parser = branch_if(|_| Ok(()), read_text("This"));
        let result = parser(&mut reader);
        assert_eq!(result, Ok(Some("This")));

        let mut parser = branch_if(
            |_| -> ParserResult<(), ()> { Err(ParserResultError::NotFound) },
            read_text("This"),
        );
        let result = parser(&mut reader);
        assert_eq!(result, Ok(None));
    }

    #[test]
    fn test_branch_if_else() {
        let mut reader = Reader::new("This is a test");
        let mut parser = branch_if_else(|_| Ok(()), read_text("This"), read_text("Th"));
        let result = parser(&mut reader);
        assert_eq!(result, Ok("This"));

        let mut reader = Reader::new("This is a test");
        let mut parser = branch_if_else(
            |_| -> ParserResult<(), ()> { Err(ParserResultError::NotFound) },
            read_text("This"),
            read_text("Th"),
        );
        let result = parser(&mut reader);
        assert_eq!(result, Ok("Th"));
    }
}

#[cfg(test)]
#[cfg(feature = "alloc")]
mod test_alloc {
    use crate::parsers::characters::read_text;

    use super::*;

    #[test]
    fn test_branch_while() {
        let mut reader = Reader::new("abcdabcda");
        let mut parser = branch_while(read_text("a"), read_text("bcd"));
        let result = parser(&mut reader);
        assert_eq!(result, Ok(vec!["bcd", "bcd"]));

        let result = parser(&mut reader);
        assert_eq!(result, Ok(vec![]));
    }
}