yapcol 0.2.0

Yet Another Parser Combinator Library - YAPCoL
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

use crate::{InputToken, Parser};

/// Applies parsers `open` and `close` around `parser`. Often used for parenthesis, brackets, etc.
///
/// # Outcome
///
/// This combinator succeeds if exactly one occurrence of `parser` is placed between `open` and
/// `close`. It fails otherwise.
///
/// # Input consumption
///
/// This combinator consumes input if:
/// - It succeeds and any of its argument parsers consume input upon success.
/// - Any of its argument parsers fail while consuming input.
///
/// # Look-ahead and backtracking
///
/// This combinator doesn't perform any lookahead and won't backtrack upon failure.
///
/// # Shortcut
///
/// This combinator has a shortcut version: [`Parser::between`].
///
/// # Arguments
///
/// - `open`: The parser that "opens" the between.
/// - `parser`: The parser that goes between `open` and `close`, whose content we're interested in.
/// - `close`: The parser that "closes" the between.
///
/// # Examples
///
/// ```
/// use yapcol::{Input, between, is};
///
/// let mut input = Input::new_from_chars("121".chars(), None);
/// let parser1 = is('1');
/// let parser2 = is('2');
/// let output = between(&parser1, &parser2, &parser1)(&mut input);
/// assert_eq!(output, Ok('2'));
/// ```
pub fn between<PO, PC, P, IT, O, OO, OC>(open: &PO, parser: &P, close: &PC) -> impl Parser<IT, O>
where
	PO: Parser<IT, OO>,
	PC: Parser<IT, OC>,
	P: Parser<IT, O>,
	IT: InputToken,
{
	move |input| {
		open(input)?;
		let output = parser(input)?;
		close(input)?;
		Ok(output)
	}
}

#[cfg(test)]
mod tests {
	use crate::input::Position;
	use crate::*;

	#[test]
	fn empty() {
		let mut input = Input::new_from_chars("".chars(), None);
		let output = between(&is('('), &is('h'), &is(')'))(&mut input);
		assert_eq!(output, Err(Error::EndOfInput(Some(Box::new('(')))));
	}

	#[test]
	fn empty_shortcut() {
		let mut input = Input::new_from_chars("".chars(), None);
		let output = is('h').between(&is('('), &is(')'))(&mut input);
		assert_eq!(output, Err(Error::EndOfInput(Some(Box::new('(')))));
	}

	#[test]
	fn success() {
		let mut input = Input::new_from_chars("(x)".chars(), None);
		let output = between(&is('('), &is('x'), &is(')'))(&mut input);
		assert_eq!(output, Ok('x'));
		assert_eq!(any()(&mut input), Err(Error::EndOfInput(None)));
	}

	#[test]
	fn success_shortcut() {
		let mut input = Input::new_from_chars("(x)".chars(), None);
		let output = is('x').between(&is('('), &is(')'))(&mut input);
		assert_eq!(output, Ok('x'));
		assert_eq!(any()(&mut input), Err(Error::EndOfInput(None)));
	}

	#[test]
	fn fail_repeated() {
		let mut input = Input::new_from_chars("(xx)".chars(), None);
		let output = between(&is('('), &is('x'), &is(')'))(&mut input);
		let mismatch = Mismatch::new(')', 'x');
		assert_eq!(
			output,
			Err(Error::UnexpectedToken(
				None,
				Position::new(1, 3),
				Some(mismatch)
			))
		);
	}

	#[test]
	fn fail_no_middle() {
		let mut input = Input::new_from_chars("()".chars(), None);
		let output = between(&is('('), &is('x'), &is(')'))(&mut input);
		let mismatch = Mismatch::new('x', ')');
		assert_eq!(
			output,
			Err(Error::UnexpectedToken(
				None,
				Position::new(1, 2),
				Some(mismatch)
			))
		);
	}

	#[test]
	fn fail_swap() {
		let mut input = Input::new_from_chars(")xx(".chars(), None);
		let output = between(&is('('), &is('x'), &is(')'))(&mut input);
		let mismatch = Mismatch::new('(', ')');
		assert_eq!(
			output,
			Err(Error::UnexpectedToken(
				None,
				Position::new(1, 1),
				Some(mismatch)
			))
		);
	}
}