hg 0.2.0

Parser for the Mercury metalanguage
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

use std::str::CharIndices;

pub struct NewlineTerminatedChars<'a> {
    char_indices: CharIndices<'a>,
    prev_char: Option<(usize, char)>,
}

impl<'a> NewlineTerminatedChars<'a> {
    #[inline]
    pub fn new(char_indices: CharIndices<'a>) -> Self {
        Self {
            char_indices, prev_char: None
        }
    }
}

impl Iterator for NewlineTerminatedChars<'_> {
    type Item = (usize, char);

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        let next = self.char_indices.next();
        match next {
            None => {
                match self.prev_char {
                    None => {
                        self.prev_char = Some((0, '\n'));
                    }
                    Some((_, '\n')) => {
                        self.prev_char = None
                    }
                    Some((index, char)) => {
                        self.prev_char = Some((index + char.len_utf8(), '\n'));
                    }
                }
                self.prev_char
            }
            Some(_) => {
                self.prev_char = next;
                next
            }
        }
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.char_indices.size_hint()
    }

    #[inline]
    fn count(self) -> usize {
        self.char_indices.count()
    }

    #[inline]
    fn last(mut self) -> Option<(usize, char)> {
        self.char_indices.next_back()
    }
}

#[cfg(test)]
mod tests {
    use crate::newline_terminated_chars::NewlineTerminatedChars;

    #[test]
    fn size_hint() {
        let str = "hiµ\n";
        let nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!((2, Some(5)), nt.size_hint());
    }

    #[test]
    fn count() {
        let str = "hiµ\n";
        let nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(4, nt.count());
    }

    #[test]
    fn last() {
        let str = "hiµ\n";
        let nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(Some((4, '\n')), nt.last());
    }

    #[test]
    fn empty() {
        let str = "";
        let mut nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(Some((0, '\n')), nt.next());
        assert_eq!(None, nt.next());
    }

    #[test]
    fn ending_with_newline() {
        let str = "hiµ\n";
        let mut nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(Some((0, 'h')), nt.next());
        assert_eq!(Some((1, 'i')), nt.next());
        assert_eq!(Some((2, 'µ')), nt.next());
        assert_eq!(Some((4, '\n')), nt.next());
        assert_eq!(None, nt.next());
    }

    #[test]
    fn ending_with_extraneous_newline() {
        let str = "hiµ\n\n";
        let mut nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(Some((0, 'h')), nt.next());
        assert_eq!(Some((1, 'i')), nt.next());
        assert_eq!(Some((2, 'µ')), nt.next());
        assert_eq!(Some((4, '\n')), nt.next());
        assert_eq!(Some((5, '\n')), nt.next());
        assert_eq!(None, nt.next());
    }

    #[test]
    fn ending_without_newline() {
        let str = "hiµ";
        let mut nt = NewlineTerminatedChars::new(str.char_indices());
        assert_eq!(Some((0, 'h')), nt.next());
        assert_eq!(Some((1, 'i')), nt.next());
        assert_eq!(Some((2, 'µ')), nt.next());
        assert_eq!(Some((4, '\n')), nt.next());
        assert_eq!(None, nt.next());
    }
}