aqua_parse 0.27.0

A parser library.
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

use super::*;
use std::hash::*;

/// Comma-separated list, where trailing comma is optional.
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq)]
pub struct List<P : Parse>{ 

	elements: Vec<P>,
	span: Span

}

impl<P : Parse> Deref for List<P> {

	type Target = [P];

	fn deref(&self) -> &Self::Target {
		
		self.elements.deref()

	}
	
}

impl<P: Hash + Parse> Hash for List<P> {

	fn hash<H: Hasher>(&self, state: &mut H) {
       
		Hash::hash(&**self, state)
    
	}

}


impl<P : Parse> Parse for List<P> {

	fn span(&self) -> &Span {
		
		&self.span

	}

	fn parse(state: &mut State) -> Result<Self> {

		#[pattern("[,]")]
		#[derive(Clone, Parse, PartialEq, Eq, PartialOrd, Ord, Hash)]
		pub struct Comma(Span);
		
		let mut elements = Vec::default();
		let start_index = state.index();
		
		loop {

			if P::can_parse(state) {

				let ok = P::parse(state)?;

				let _ = Many::<whitespace::Whitespace>::parse(state);

				elements.push(ok);

				if Comma::can_parse(state) {

					let _ = Comma::parse(state)?;

					let _ = Many::<whitespace::Whitespace>::parse(state);

				}

				else { break; }

			}

			else { break; }
	
		}

		let end_index = state.index();
		let range = start_index .. end_index;
		let page = state.page();

		let span = Span::new(page, range);	

		Ok( Self { elements, span } )

	}

}