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
125
126
127

pub use repeats::*;
pub use tuples::*;

use crate::parsers::helpers::not_found_restore;
use crate::result::ParserResult;
use crate::Reader;

mod repeats;
mod tuples;

/// Matches an object from the first parser and discards it,
/// then gets an object from the second parser, and finally
/// matches an object from the third parser and discards it.
pub fn delimited<'a, Pre, Con, Pos, C, RPre, R, RPos, Err>(
    mut prefix: Pre,
    mut content: Con,
    mut postfix: Pos,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>
where
    Pre: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<RPre, Err>,
    Con: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
    Pos: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<RPos, Err>,
{
    not_found_restore(move |reader| {
        let _ = prefix(reader)?;
        let result = content(reader)?;
        let _ = postfix(reader)?;

        Ok(result)
    })
}

/// Matches an object from the first parser and discards it, then gets an object from the second parser.
pub fn preceded<'a, Pre, Con, C, RPre, R, Err>(
    mut prefix: Pre,
    mut content: Con,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>
where
    Pre: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<RPre, Err>,
    Con: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
{
    not_found_restore(move |reader| {
        let _ = prefix(reader)?;
        content(reader)
    })
}

/// Gets an object from the first parser, then matches an object from the second parser and discards it.
pub fn terminated<'a, Con, Pos, C, R, RPos, Err>(
    mut content: Con,
    mut postfix: Pos,
) -> impl FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>
where
    Con: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<R, Err>,
    Pos: FnMut(&mut Reader<'a, Err, C>) -> ParserResult<RPos, Err>,
{
    not_found_restore(move |reader| {
        let result = content(reader)?;
        let _ = postfix(reader)?;

        Ok(result)
    })
}

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

#[cfg(test)]
mod test {
    use crate::parsers::characters::{ascii_alpha1, read_text};
    use crate::result::ParserResultError;

    use super::*;

    #[test]
    fn test_delimited() {
        let mut reader = Reader::new("(abcd)");
        let mut parser = delimited(read_text("("), ascii_alpha1, read_text(")"));
        let result = parser(&mut reader);
        assert_eq!(result, Ok("abcd"));

        let mut reader = Reader::new("abcd)");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));

        let mut reader = Reader::new("()");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));

        let mut reader = Reader::new("(abcd");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));
    }

    #[test]
    fn test_preceded() {
        let mut reader = Reader::new("(abcd)");
        let mut parser = preceded(read_text("("), ascii_alpha1);
        let result = parser(&mut reader);
        assert_eq!(result, Ok("abcd"));

        let mut reader = Reader::new("abcd)");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));

        let mut reader = Reader::new("()");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));
    }

    #[test]
    fn test_terminated() {
        let mut reader = Reader::new("abcd)");
        let mut parser = terminated(ascii_alpha1, read_text(")"));
        let result = parser(&mut reader);
        assert_eq!(result, Ok("abcd"));

        let mut reader = Reader::new("abcd");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));

        let mut reader = Reader::new(")");
        let result = parser(&mut reader);
        assert_eq!(result, Err(ParserResultError::NotFound));
    }
}