pom 2.0.0-alpha

PEG parser combinators using operator overloading without macros.
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

use super::{Result, Error};

/// Parser trait.
pub trait Parser<'a, I> {
	type Output;
	/// Parse input at start position, return output and finished position.
	fn parse(&self, input: &'a [I], start: usize) -> Result<(Self::Output, usize)>;
}

impl<'a, I: 'a, O, F> Parser<'a, I> for F where F: Fn(&'a [I], usize) -> Result<(O, usize)> {
	type Output = O;

	fn parse(&self, input: &'a [I], start: usize) -> Result<(O, usize)> {
		self(input, start)
	}
}

// impl<'a, I: 'a, O, F> Parser<'a, I> for Box<F> where F: Fn(&'a [I], usize) -> Result<(O, usize)> {
// 	type Output = O;

// 	fn parse(&self, input: &'a [I], start: usize) -> Result<(O, usize)> {
// 		self(input, start)
// 	}
// }

// impl<'a> Parser<'a, u8, &'a [u8]> for &'a str {
// 	fn parse(&self, input: &'a [u8], start: usize) -> Result<(&'a [u8], usize)> {
// 		seq(self.as_bytes()).parse(input, start)
// 	}
// }

impl<'a> Parser<'a, char> for &'a str {
	type Output = &'a str;

	fn parse(&self, input: &'a [char], start: usize) -> Result<(&'a str, usize)> {
		let mut pos = start;
		for c in self.chars() {
			if let Some(&s) = input.get(pos) {
				if c != s {
					return Err(Error::Mismatch {
						message: format!("seq {:?} expect: {:?}, found: {:?}", self, c, s),
						position: pos,
					});
				}
			} else {
				return Err(Error::Incomplete);
			}
			pos += 1;
		}
		return Ok((self, pos));
	}
}