parsy 0.2.1

An easy-to-use, efficient 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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::marker::PhantomData;

use crate::{container::Container, Eaten, PResult, Parser, ParserInput};

pub struct SeparatedBy<T, TP: Parser<T>, S, SP: Parser<S>, C: Container<T>> {
    parser: TP,
    separator: SP,
    min: Option<usize>,
    max: Option<usize>,
    exactly: Option<usize>,
    _t: PhantomData<T>,
    _s: PhantomData<S>,
    _c: PhantomData<C>,
}

impl<T, TP: Parser<T>, S, SP: Parser<S>, C: Container<T>> SeparatedBy<T, TP, S, SP, C> {
    pub fn new(parser: TP, separator: SP) -> Self {
        Self {
            parser,
            separator,
            min: None,
            max: None,
            exactly: None,
            _t: PhantomData,
            _s: PhantomData,
            _c: PhantomData,
        }
    }

    pub fn at_least(mut self, min: usize) -> Self {
        assert!(
            self.exactly.is_none(),
            "Cannot specify both a minimum and an exact number of repetitions"
        );

        if let Some(max) = self.max {
            assert!(min <= max, "Minimum number of repetitions ({min}) cannot be higher than the maximum ({max}) number of repetitoins");
        }

        self.min = Some(min);
        self
    }

    pub fn at_most(mut self, max: usize) -> Self {
        assert!(
            self.exactly.is_none(),
            "Cannot specify both a maximum and an exact number of repetitions"
        );

        if let Some(min) = self.min {
            assert!(min <= max, "Minimum number of repetitions ({min}) cannot be higher than the maximum ({max}) number of repetitoins");
        }

        self.max = Some(max);
        self
    }

    pub fn exactly(mut self, exactly: usize) -> Self {
        assert!(
            self.min.is_none(),
            "Cannot specify both a minimum and an exact number of repetitions"
        );

        assert!(
            self.max.is_none(),
            "Cannot specify both a maximum and an exact number of repetitions"
        );

        self.exactly = Some(exactly);
        self
    }
}

// NOTE: This is required because of https://github.com/rust-lang/rust/issues/26925
impl<T, TP: Parser<T> + Clone, S, SP: Parser<S> + Clone, C: Container<T>> Clone
    for SeparatedBy<T, TP, S, SP, C>
{
    fn clone(&self) -> Self {
        Self {
            parser: self.parser.clone(),
            separator: self.separator.clone(),
            min: self.min,
            max: self.max,
            exactly: self.exactly,
            _t: self._t,
            _s: self._s,
            _c: self._c,
        }
    }
}

impl<T, TP: Parser<T>, S, SP: Parser<S>, C: Container<T>> Parser<C>
    for SeparatedBy<T, TP, S, SP, C>
{
    fn parse_inner(&self, input: &mut ParserInput) -> PResult<C> {
        let mut out = C::create();
        let mut size = 0;
        let mut ate = 0;
        let start = input.at();

        loop {
            let parsed = match self.parser.parse(input) {
                Ok(parsed) => parsed,
                Err(err) if err.is_critical() => return Err(err),
                Err(_) => break,
            };

            out.add(parsed.data);
            ate += parsed.at.len;
            size += 1;

            if let Some(max) = self.max {
                if size > max {
                    break;
                }
            }

            if let Some(exactly) = self.exactly {
                if size == exactly {
                    break;
                }
            }

            match self.separator.parse(input) {
                Ok(parsed) => ate += parsed.at.len,
                Err(err) => {
                    if err.is_critical() {
                        return Err(err);
                    } else {
                        break;
                    }
                }
            }
        }

        if let Some(min) = self.min {
            if size < min {
                return Err(input.range(0).custom_err("Not enough repetitions"));
            }
        }

        Ok(Eaten::ate(start.range(ate), out))
    }
}