parlib 0.1.1

A barebones parser combinator library, inspired by Haskells parsec
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

use crate::traits::Parser;

pub struct StringParser;

impl Parser for StringParser {
    type Output = String;
    fn parse(&self, input: &str) -> crate::type_alias::ParserRes<Self::Output> {
        // First, we will make sure that the first character is "
        let mut chars = input.chars().peekable();
        let mut acc = String::new();

        if chars.next() != Some('"') {
            return Err(crate::errors::ParsingError::PatternNotFound(
                "String must start with \"".to_string(),
            ));
        }

        loop {
            match chars.next() {
                Some('"') => break,
                Some('\\') => {
                    let char_after = chars.next().unwrap();
                    acc.push('\\');
                    acc.push(char_after);
                }
                Some(c) => acc.push(c),
                None => {
                    return Err(crate::errors::ParsingError::PatternNotFound(
                        "Did not find closing quote \"".to_string(),
                    ))
                }
            };
        }

        Ok((acc, chars.collect()))
    }
}

pub fn string_parser() -> impl Parser<Output = String> {
    StringParser
}

#[cfg(test)]
mod string_parser_test {
    use crate::parsers::string_p::string_parser;
    use crate::traits::Parser;

    #[test]
    fn string_parser_test() {
        let sp = string_parser();
        let x = sp.parse("\"This is some string\" and this is the rest");
        assert_eq!(
            x,
            Ok((
                "This is some string".to_string(),
                " and this is the rest".to_string()
            ))
        );
    }
}