neure 0.10.1

A fast little combinational parsing 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
145
146
147
148
149
150
151
152

use super::IndexBySpan;

use crate::span::Span;

#[derive(Debug)]
pub struct IteratorBySpan<'a, 'b, T: ?Sized> {
    cur: usize,

    value: &'a T,

    spans: &'b [Span],
}

impl<'a, 'b, T: ?Sized> Clone for IteratorBySpan<'a, 'b, T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<'a, 'b, T: ?Sized> Copy for IteratorBySpan<'a, 'b, T> {}

impl<'a, 'b, T: ?Sized> IteratorBySpan<'a, 'b, T> {
    pub const fn new(str: &'a T, spans: &'b [Span]) -> Self {
        Self {
            value: str,
            spans,
            cur: 0,
        }
    }
}

impl<'a, T> Iterator for IteratorBySpan<'a, '_, T>
where
    T: ?Sized + IndexBySpan,
{
    type Item = &'a <T as IndexBySpan>::Output;

    fn next(&mut self) -> Option<Self::Item> {
        let cur = self.cur;

        self.cur += 1;
        self.spans.get(cur).and_then(|v| self.value.get_by_span(v))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let size = self.spans.len() - self.cur;

        (size, Some(size))
    }
}

impl<T: ?Sized + IndexBySpan> ExactSizeIterator for IteratorBySpan<'_, '_, T> {}

#[derive(Debug, Clone)]
pub struct SpanIterator<'a> {
    offset: usize,

    spans: &'a [Span],
}

impl<'a> SpanIterator<'a> {
    pub const fn new(spans: &'a [Span]) -> Self {
        Self { offset: 0, spans }
    }
}

impl Iterator for SpanIterator<'_> {
    type Item = Span;

    fn next(&mut self) -> Option<Self::Item> {
        let offset = self.offset;

        if offset < self.spans.len() {
            self.offset += 1;
            self.spans.get(offset).copied()
        } else {
            None
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub struct IteratorByOptionSpan<'a, 'b, T: ?Sized> {
    cur: usize,

    value: &'a T,

    spans: &'b [Option<Span>],
}

impl<'a, 'b, T: ?Sized> IteratorByOptionSpan<'a, 'b, T> {
    pub const fn new(str: &'a T, spans: &'b [Option<Span>]) -> Self {
        Self {
            value: str,
            spans,
            cur: 0,
        }
    }
}

impl<'a, T> Iterator for IteratorByOptionSpan<'a, '_, T>
where
    T: ?Sized + IndexBySpan,
{
    type Item = &'a <T as IndexBySpan>::Output;

    fn next(&mut self) -> Option<Self::Item> {
        let cur = self.cur;

        self.cur += 1;
        self.spans
            .get(cur)
            .and_then(|v| v.as_ref())
            .and_then(|v| self.value.get_by_span(v))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let size = self.spans.len() - self.cur;

        (size, Some(size))
    }
}

impl<T: ?Sized + IndexBySpan> ExactSizeIterator for IteratorByOptionSpan<'_, '_, T> {}

#[derive(Debug, Clone)]
pub struct OptionSpanIterator<'a> {
    offset: usize,

    spans: &'a [Option<Span>],
}

impl<'a> OptionSpanIterator<'a> {
    pub const fn new(spans: &'a [Option<Span>]) -> Self {
        Self { offset: 0, spans }
    }
}

impl Iterator for OptionSpanIterator<'_> {
    type Item = Span;

    fn next(&mut self) -> Option<Self::Item> {
        let offset = self.offset;

        if offset < self.spans.len() {
            self.offset += 1;
            self.spans.get(offset).and_then(|v| v.as_ref()).copied()
        } else {
            None
        }
    }
}