1// pest. The Elegant Parser
2// Copyright (c) 2018 Dragoș Tiselice
3//
4// Licensed under the Apache License, Version 2.0
5// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
6// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7// option. All files in the project carrying such notice may not be copied,
8// modified, or distributed except according to those terms.
9
10use alloc::format;
11use alloc::rc::Rc;
12use alloc::string::String;
13use alloc::vec::Vec;
14use core::fmt;
15use core::hash::{Hash, Hasher};
16use core::iter::Filter;
17use core::ptr;
18use core::str;
19
20#[cfg(feature = "pretty-print")]
21use serde::ser::SerializeStruct;
22
23use super::flat_pairs::{self, FlatPairs};
24use super::line_index::LineIndex;
25use super::pair::{self, Pair};
26use super::queueable_token::QueueableToken;
27use super::tokens::{self, Tokens};
28use crate::RuleType;
29
30/// An iterator over [`Pair`]s. It is created by [`pest::state`] and [`Pair::into_inner`].
31///
32/// [`Pair`]: struct.Pair.html
33/// [`pest::state`]: ../fn.state.html
34/// [`Pair::into_inner`]: struct.Pair.html#method.into_inner
35#[derive(Clone)]
36pub struct Pairs<'i, R> {
37 queue: Rc<Vec<QueueableToken<'i, R>>>,
38 input: &'i str,
39 start: usize,
40 end: usize,
41 pairs_count: usize,
42 line_index: Rc<LineIndex>,
43}
44
45pub fn new<'i, R: RuleType>(
46 queue: Rc<Vec<QueueableToken<'i, R>>>,
47 input: &'i str,
48 line_index: Option<Rc<LineIndex>>,
49 start: usize,
50 end: usize,
51) -> Pairs<'i, R> {
52 let line_index = match line_index {
53 Some(line_index) => line_index,
54 None => {
55 let last_input_pos = queue
56 .last()
57 .map(|token| match *token {
58 QueueableToken::Start { input_pos, .. }
59 | QueueableToken::End { input_pos, .. } => input_pos,
60 })
61 .unwrap_or(0);
62
63 Rc::new(LineIndex::new(&input[..last_input_pos]))
64 }
65 };
66
67 let mut pairs_count = 0;
68 let mut cursor = start;
69 while cursor < end {
70 cursor = match queue[cursor] {
71 QueueableToken::Start {
72 end_token_index, ..
73 } => end_token_index,
74 _ => unreachable!(),
75 } + 1;
76 pairs_count += 1;
77 }
78
79 Pairs {
80 queue,
81 input,
82 start,
83 end,
84 pairs_count,
85 line_index,
86 }
87}
88
89impl<'i, R: RuleType> Pairs<'i, R> {
90 /// Captures a slice from the `&str` defined by the starting position of the first token `Pair`
91 /// and the ending position of the last token `Pair` of the `Pairs`. This also captures
92 /// the input between those two token `Pair`s.
93 ///
94 /// # Examples
95 ///
96 /// ```
97 /// # use std::rc::Rc;
98 /// # use pest;
99 /// # #[allow(non_camel_case_types)]
100 /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
101 /// enum Rule {
102 /// a,
103 /// b
104 /// }
105 ///
106 /// let input = "a b";
107 /// let pairs = pest::state(input, |state| {
108 /// // generating Token pairs with Rule::a and Rule::b ...
109 /// # state.rule(Rule::a, |s| s.match_string("a")).and_then(|s| s.skip(1))
110 /// # .and_then(|s| s.rule(Rule::b, |s| s.match_string("b")))
111 /// }).unwrap();
112 ///
113 /// assert_eq!(pairs.as_str(), "a b");
114 /// ```
115 #[inline]
116 pub fn as_str(&self) -> &'i str {
117 if self.start < self.end {
118 let start = self.pos(self.start);
119 let end = self.pos(self.end - 1);
120 // Generated positions always come from Positions and are UTF-8 borders.
121 &self.input[start..end]
122 } else {
123 ""
124 }
125 }
126
127 /// Returns the input string of `Pairs`.
128 ///
129 /// This function returns the input string of `Pairs` as a `&str`. This is the source string
130 /// from which `Pairs` was created. The returned `&str` can be used to examine the contents of
131 /// `Pairs` or to perform further processing on the string.
132 ///
133 /// # Examples
134 ///
135 /// ```
136 /// # use std::rc::Rc;
137 /// # use pest;
138 /// # #[allow(non_camel_case_types)]
139 /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
140 /// enum Rule {
141 /// a,
142 /// b
143 /// }
144 ///
145 /// // Example: Get input string from Pairs
146 ///
147 /// let input = "a b";
148 /// let pairs = pest::state(input, |state| {
149 /// // generating Token pairs with Rule::a and Rule::b ...
150 /// # state.rule(Rule::a, |s| s.match_string("a")).and_then(|s| s.skip(1))
151 /// # .and_then(|s| s.rule(Rule::b, |s| s.match_string("b")))
152 /// }).unwrap();
153 ///
154 /// assert_eq!(pairs.as_str(), "a b");
155 /// assert_eq!(input, pairs.get_input());
156 /// ```
157 pub fn get_input(&self) -> &'i str {
158 self.input
159 }
160
161 /// Captures inner token `Pair`s and concatenates resulting `&str`s. This does not capture
162 /// the input between token `Pair`s.
163 ///
164 /// # Examples
165 ///
166 /// ```
167 /// # use std::rc::Rc;
168 /// # use pest;
169 /// # #[allow(non_camel_case_types)]
170 /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
171 /// enum Rule {
172 /// a,
173 /// b
174 /// }
175 ///
176 /// let input = "a b";
177 /// let pairs = pest::state(input, |state| {
178 /// // generating Token pairs with Rule::a and Rule::b ...
179 /// # state.rule(Rule::a, |s| s.match_string("a")).and_then(|s| s.skip(1))
180 /// # .and_then(|s| s.rule(Rule::b, |s| s.match_string("b")))
181 /// }).unwrap();
182 ///
183 /// assert_eq!(pairs.concat(), "ab");
184 /// ```
185 #[inline]
186 pub fn concat(&self) -> String {
187 self.clone()
188 .fold(String::new(), |string, pair| string + pair.as_str())
189 }
190
191 /// Flattens the `Pairs`.
192 ///
193 /// # Examples
194 ///
195 /// ```
196 /// # use std::rc::Rc;
197 /// # use pest;
198 /// # #[allow(non_camel_case_types)]
199 /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
200 /// enum Rule {
201 /// a,
202 /// b
203 /// }
204 ///
205 /// let input = "";
206 /// let pairs = pest::state(input, |state| {
207 /// // generating nested Token pair with Rule::b inside Rule::a
208 /// # state.rule(Rule::a, |state| {
209 /// # state.rule(Rule::b, |s| Ok(s))
210 /// # })
211 /// }).unwrap();
212 /// let tokens: Vec<_> = pairs.flatten().tokens().collect();
213 ///
214 /// assert_eq!(tokens.len(), 4);
215 /// ```
216 #[inline]
217 pub fn flatten(self) -> FlatPairs<'i, R> {
218 flat_pairs::new(
219 self.queue,
220 self.input,
221 self.line_index,
222 self.start,
223 self.end,
224 )
225 }
226
227 /// Finds the first pair that has its node or branch tagged with the provided
228 /// label. Searches in the flattened [`Pairs`] iterator.
229 ///
230 /// # Examples
231 ///
232 /// Try to recognize the branch between add and mul
233 /// ```
234 /// use pest::{state, ParseResult, ParserState};
235 /// #[allow(non_camel_case_types)]
236 /// #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
237 /// enum Rule {
238 /// number, // 0..9
239 /// add, // num + num
240 /// mul, // num * num
241 /// }
242 /// fn mark_branch(
243 /// state: Box<ParserState<'_, Rule>>,
244 /// ) -> ParseResult<Box<ParserState<'_, Rule>>> {
245 /// expr(state, Rule::mul, "*")
246 /// .and_then(|state| state.tag_node("mul"))
247 /// .or_else(|state| expr(state, Rule::add, "+"))
248 /// .and_then(|state| state.tag_node("add"))
249 /// }
250 /// fn expr<'a>(
251 /// state: Box<ParserState<'a, Rule>>,
252 /// r: Rule,
253 /// o: &'static str,
254 /// ) -> ParseResult<Box<ParserState<'a, Rule>>> {
255 /// state.rule(r, |state| {
256 /// state.sequence(|state| {
257 /// number(state)
258 /// .and_then(|state| state.tag_node("lhs"))
259 /// .and_then(|state| state.match_string(o))
260 /// .and_then(number)
261 /// .and_then(|state| state.tag_node("rhs"))
262 /// })
263 /// })
264 /// }
265 /// fn number(state: Box<ParserState<'_, Rule>>) -> ParseResult<Box<ParserState<'_, Rule>>> {
266 /// state.rule(Rule::number, |state| state.match_range('0'..'9'))
267 /// }
268 /// let input = "1+2";
269 /// let pairs = state(input, mark_branch).unwrap();
270 /// assert_eq!(pairs.find_first_tagged("add").unwrap().as_rule(), Rule::add);
271 /// assert_eq!(pairs.find_first_tagged("mul"), None);
272 /// ```
273 #[inline]
274 pub fn find_first_tagged(&self, tag: &'i str) -> Option<Pair<'i, R>> {
275 self.clone().find_tagged(tag).next()
276 }
277
278 /// Returns the iterator over pairs that have their node or branch tagged
279 /// with the provided label. The iterator is built from a flattened [`Pairs`] iterator.
280 ///
281 /// # Examples
282 ///
283 /// Try to recognize the node between left and right hand side
284 /// ```
285 /// use pest::{state, ParseResult, ParserState};
286 /// #[allow(non_camel_case_types)]
287 /// #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
288 /// enum Rule {
289 /// number, // 0..9
290 /// add, // num + num
291 /// mul, // num * num
292 /// }
293 /// fn mark_branch(
294 /// state: Box<ParserState<'_, Rule>>,
295 /// ) -> ParseResult<Box<ParserState<'_, Rule>>> {
296 /// expr(state, Rule::mul, "*")
297 /// .and_then(|state| state.tag_node("mul"))
298 /// .or_else(|state| expr(state, Rule::add, "+"))
299 /// .and_then(|state| state.tag_node("add"))
300 /// }
301 /// fn expr<'a>(
302 /// state: Box<ParserState<'a, Rule>>,
303 /// r: Rule,
304 /// o: &'static str,
305 /// ) -> ParseResult<Box<ParserState<'a, Rule>>> {
306 /// state.rule(r, |state| {
307 /// state.sequence(|state| {
308 /// number(state)
309 /// .and_then(|state| state.tag_node("lhs"))
310 /// .and_then(|state| state.match_string(o))
311 /// .and_then(number)
312 /// .and_then(|state| state.tag_node("rhs"))
313 /// })
314 /// })
315 /// }
316 /// fn number(state: Box<ParserState<'_, Rule>>) -> ParseResult<Box<ParserState<'_, Rule>>> {
317 /// state.rule(Rule::number, |state| state.match_range('0'..'9'))
318 /// }
319 ///
320 /// let input = "1+2";
321 /// let pairs = state(input, mark_branch).unwrap();
322 /// let mut left_numbers = pairs.find_tagged("lhs");
323 /// assert_eq!(left_numbers.next().unwrap().as_str(), "1");
324 /// assert_eq!(left_numbers.next(), None);
325 /// ```
326 #[inline]
327 pub fn find_tagged(
328 self,
329 tag: &'i str,
330 ) -> Filter<FlatPairs<'i, R>, impl FnMut(&Pair<'i, R>) -> bool + '_> {
331 self.flatten()
332 .filter(move |pair: &Pair<'i, R>| matches!(pair.as_node_tag(), Some(nt) if nt == tag))
333 }
334
335 /// Returns the `Tokens` for the `Pairs`.
336 ///
337 /// # Examples
338 ///
339 /// ```
340 /// # use std::rc::Rc;
341 /// # use pest;
342 /// # #[allow(non_camel_case_types)]
343 /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
344 /// enum Rule {
345 /// a
346 /// }
347 ///
348 /// let input = "";
349 /// let pairs = pest::state(input, |state| {
350 /// // generating Token pair with Rule::a ...
351 /// # state.rule(Rule::a, |s| Ok(s))
352 /// }).unwrap();
353 /// let tokens: Vec<_> = pairs.tokens().collect();
354 ///
355 /// assert_eq!(tokens.len(), 2);
356 /// ```
357 #[inline]
358 pub fn tokens(self) -> Tokens<'i, R> {
359 tokens::new(self.queue, self.input, self.start, self.end)
360 }
361
362 /// Peek at the first inner `Pair` without changing the position of this iterator.
363 #[inline]
364 pub fn peek(&self) -> Option<Pair<'i, R>> {
365 if self.start < self.end {
366 Some(pair::new(
367 Rc::clone(&self.queue),
368 self.input,
369 Rc::clone(&self.line_index),
370 self.start,
371 ))
372 } else {
373 None
374 }
375 }
376
377 /// Generates a string that stores the lexical information of `self` in
378 /// a pretty-printed JSON format.
379 #[cfg(feature = "pretty-print")]
380 pub fn to_json(&self) -> String {
381 ::serde_json::to_string_pretty(self).expect("Failed to pretty-print Pairs to json.")
382 }
383
384 fn pair(&self) -> usize {
385 match self.queue[self.start] {
386 QueueableToken::Start {
387 end_token_index, ..
388 } => end_token_index,
389 _ => unreachable!(),
390 }
391 }
392
393 fn pair_from_end(&self) -> usize {
394 match self.queue[self.end - 1] {
395 QueueableToken::End {
396 start_token_index, ..
397 } => start_token_index,
398 _ => unreachable!(),
399 }
400 }
401
402 fn pos(&self, index: usize) -> usize {
403 match self.queue[index] {
404 QueueableToken::Start { input_pos, .. } | QueueableToken::End { input_pos, .. } => {
405 input_pos
406 }
407 }
408 }
409}
410
411impl<'i, R: RuleType> ExactSizeIterator for Pairs<'i, R> {
412 #[inline]
413 fn len(&self) -> usize {
414 self.pairs_count
415 }
416}
417
418impl<'i, R: RuleType> Iterator for Pairs<'i, R> {
419 type Item = Pair<'i, R>;
420
421 fn next(&mut self) -> Option<Self::Item> {
422 let pair: Pair<'i, R> = self.peek()?;
423
424 self.start = self.pair() + 1;
425 self.pairs_count -= 1;
426 Some(pair)
427 }
428
429 fn size_hint(&self) -> (usize, Option<usize>) {
430 let len: usize = <Self as ExactSizeIterator>::len(self);
431 (len, Some(len))
432 }
433}
434
435impl<'i, R: RuleType> DoubleEndedIterator for Pairs<'i, R> {
436 fn next_back(&mut self) -> Option<Self::Item> {
437 if self.end <= self.start {
438 return None;
439 }
440
441 self.end = self.pair_from_end();
442 self.pairs_count -= 1;
443
444 let pair: Pair<'_, R> = pair::new(
445 queue:Rc::clone(&self.queue),
446 self.input,
447 line_index:Rc::clone(&self.line_index),
448 self.end,
449 );
450
451 Some(pair)
452 }
453}
454
455impl<'i, R: RuleType> fmt::Debug for Pairs<'i, R> {
456 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
457 f.debug_list().entries(self.clone()).finish()
458 }
459}
460
461impl<'i, R: RuleType> fmt::Display for Pairs<'i, R> {
462 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
463 write!(
464 f,
465 "[{}]",
466 self.clone()
467 .map(|pair| format!("{}", pair))
468 .collect::<Vec<_>>()
469 .join(", ")
470 )
471 }
472}
473
474impl<'i, R: PartialEq> PartialEq for Pairs<'i, R> {
475 fn eq(&self, other: &Pairs<'i, R>) -> bool {
476 Rc::ptr_eq(&self.queue, &other.queue)
477 && ptr::eq(self.input, b:other.input)
478 && self.start == other.start
479 && self.end == other.end
480 }
481}
482
483impl<'i, R: Eq> Eq for Pairs<'i, R> {}
484
485impl<'i, R: Hash> Hash for Pairs<'i, R> {
486 fn hash<H: Hasher>(&self, state: &mut H) {
487 (&*self.queue as *const Vec<QueueableToken<'i, R>>).hash(state);
488 (self.input as *const str).hash(state);
489 self.start.hash(state);
490 self.end.hash(state);
491 }
492}
493
494#[cfg(feature = "pretty-print")]
495impl<'i, R: RuleType> ::serde::Serialize for Pairs<'i, R> {
496 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
497 where
498 S: ::serde::Serializer,
499 {
500 let start = self.pos(self.start);
501 let end = self.pos(self.end - 1);
502 let pairs = self.clone().collect::<Vec<_>>();
503
504 let mut ser = serializer.serialize_struct("Pairs", 2)?;
505 ser.serialize_field("pos", &(start, end))?;
506 ser.serialize_field("pairs", &pairs)?;
507 ser.end()
508 }
509}
510
511#[cfg(test)]
512mod tests {
513 use super::super::super::macros::tests::*;
514 use super::super::super::Parser;
515 use alloc::borrow::ToOwned;
516 use alloc::boxed::Box;
517 use alloc::format;
518 use alloc::vec;
519 use alloc::vec::Vec;
520
521 #[test]
522 #[cfg(feature = "pretty-print")]
523 fn test_pretty_print() {
524 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
525
526 let expected = r#"{
527 "pos": [
528 0,
529 5
530 ],
531 "pairs": [
532 {
533 "pos": [
534 0,
535 3
536 ],
537 "rule": "a",
538 "inner": {
539 "pos": [
540 1,
541 2
542 ],
543 "pairs": [
544 {
545 "pos": [
546 1,
547 2
548 ],
549 "rule": "b",
550 "inner": "b"
551 }
552 ]
553 }
554 },
555 {
556 "pos": [
557 4,
558 5
559 ],
560 "rule": "c",
561 "inner": "e"
562 }
563 ]
564}"#;
565
566 assert_eq!(expected, pairs.to_json());
567 }
568
569 #[test]
570 fn as_str() {
571 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
572
573 assert_eq!(pairs.as_str(), "abcde");
574 }
575
576 #[test]
577 fn get_input_of_pairs() {
578 let input = "abcde";
579 let pairs = AbcParser::parse(Rule::a, input).unwrap();
580
581 assert_eq!(pairs.get_input(), input);
582 }
583
584 #[test]
585 fn as_str_empty() {
586 let mut pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
587
588 assert_eq!(pairs.nth(1).unwrap().into_inner().as_str(), "");
589 }
590
591 #[test]
592 fn concat() {
593 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
594
595 assert_eq!(pairs.concat(), "abce");
596 }
597
598 #[test]
599 fn pairs_debug() {
600 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
601
602 #[rustfmt::skip]
603 assert_eq!(
604 format!("{:?}", pairs),
605 "[\
606 Pair { rule: a, span: Span { str: \"abc\", start: 0, end: 3 }, inner: [\
607 Pair { rule: b, span: Span { str: \"b\", start: 1, end: 2 }, inner: [] }\
608 ] }, \
609 Pair { rule: c, span: Span { str: \"e\", start: 4, end: 5 }, inner: [] }\
610 ]"
611 .to_owned()
612 );
613 }
614
615 #[test]
616 fn pairs_display() {
617 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
618
619 assert_eq!(
620 format!("{}", pairs),
621 "[a(0, 3, [b(1, 2)]), c(4, 5)]".to_owned()
622 );
623 }
624
625 #[test]
626 fn iter_for_pairs() {
627 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
628 assert_eq!(
629 pairs.map(|p| p.as_rule()).collect::<Vec<Rule>>(),
630 vec![Rule::a, Rule::c]
631 );
632 }
633
634 #[test]
635 fn double_ended_iter_for_pairs() {
636 let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
637 assert_eq!(
638 pairs.rev().map(|p| p.as_rule()).collect::<Vec<Rule>>(),
639 vec![Rule::c, Rule::a]
640 );
641 }
642
643 #[test]
644 fn test_line_col() {
645 let mut pairs = AbcParser::parse(Rule::a, "abc\nefgh").unwrap();
646 let pair = pairs.next().unwrap();
647 assert_eq!(pair.as_str(), "abc");
648 assert_eq!(pair.line_col(), (1, 1));
649
650 let pair = pairs.next().unwrap();
651 assert_eq!(pair.as_str(), "e");
652 assert_eq!(pair.line_col(), (2, 1));
653
654 let pair = pairs.next().unwrap();
655 assert_eq!(pair.as_str(), "fgh");
656 assert_eq!(pair.line_col(), (2, 2));
657 }
658
659 #[test]
660 fn test_rev_iter_line_col() {
661 let mut pairs = AbcParser::parse(Rule::a, "abc\nefgh").unwrap().rev();
662 let pair = pairs.next().unwrap();
663 assert_eq!(pair.as_str(), "fgh");
664 assert_eq!(pair.line_col(), (2, 2));
665
666 let pair = pairs.next().unwrap();
667 assert_eq!(pair.as_str(), "e");
668 assert_eq!(pair.line_col(), (2, 1));
669
670 let pair = pairs.next().unwrap();
671 assert_eq!(pair.as_str(), "abc");
672 assert_eq!(pair.line_col(), (1, 1));
673 }
674
675 #[test]
676 // false positive: pest uses `..` as a complete range (historically)
677 #[allow(clippy::almost_complete_range)]
678 fn test_tag_node_branch() {
679 use crate::{state, ParseResult, ParserState};
680 #[allow(non_camel_case_types)]
681 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
682 enum Rule {
683 number, // 0..9
684 add, // num + num
685 mul, // num * num
686 }
687 fn mark_branch(
688 state: Box<ParserState<'_, Rule>>,
689 ) -> ParseResult<Box<ParserState<'_, Rule>>> {
690 expr(state, Rule::mul, "*")
691 .and_then(|state| state.tag_node("mul"))
692 .or_else(|state| expr(state, Rule::add, "+"))
693 .and_then(|state| state.tag_node("add"))
694 }
695 fn expr<'a>(
696 state: Box<ParserState<'a, Rule>>,
697 r: Rule,
698 o: &'static str,
699 ) -> ParseResult<Box<ParserState<'a, Rule>>> {
700 state.rule(r, |state| {
701 state.sequence(|state| {
702 number(state)
703 .and_then(|state| state.tag_node("lhs"))
704 .and_then(|state| state.match_string(o))
705 .and_then(number)
706 .and_then(|state| state.tag_node("rhs"))
707 })
708 })
709 }
710 fn number(state: Box<ParserState<'_, Rule>>) -> ParseResult<Box<ParserState<'_, Rule>>> {
711 state.rule(Rule::number, |state| state.match_range('0'..'9'))
712 }
713 let input = "1+2";
714 let pairs = state(input, mark_branch).unwrap();
715 assert_eq!(pairs.find_first_tagged("add").unwrap().as_rule(), Rule::add);
716 assert_eq!(pairs.find_first_tagged("mul"), None);
717
718 let mut left_numbers = pairs.clone().find_tagged("lhs");
719
720 assert_eq!(left_numbers.next().unwrap().as_str(), "1");
721 assert_eq!(left_numbers.next(), None);
722 let mut right_numbers = pairs.find_tagged("rhs");
723
724 assert_eq!(right_numbers.next().unwrap().as_str(), "2");
725 assert_eq!(right_numbers.next(), None);
726 }
727
728 #[test]
729 fn exact_size_iter_for_pairs() {
730 let pairs = AbcParser::parse(Rule::a, "abc\nefgh").unwrap();
731 assert_eq!(pairs.len(), pairs.count());
732
733 let pairs = AbcParser::parse(Rule::a, "abc\nefgh").unwrap().rev();
734 assert_eq!(pairs.len(), pairs.count());
735
736 let mut pairs = AbcParser::parse(Rule::a, "abc\nefgh").unwrap();
737 let pairs_len = pairs.len();
738 let _ = pairs.next().unwrap();
739 assert_eq!(pairs.count() + 1, pairs_len);
740 }
741}
742