yapcol 0.1.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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use crate::*;

#[test]
fn empty() {
	let tokens: Vec<&str> = Vec::new();
	let mut input = Input::new(tokens);
	let parser = is("hello");
	let output = attempt(&parser)(&mut input);
	assert_eq!(output, Err(Error::EndOfInput));
}

#[test]
fn success_consumes() {
	let tokens = vec!["hello", "world", "foo"];
	let mut input = Input::new(tokens);
	let parser = is("hello");
	let output = attempt(&parser)(&mut input);
	assert_eq!(output, Ok("hello"));
	// After attempt succeeds, input should be consumed.
	assert_eq!(is("world")(&mut input), Ok("world"));
	assert_eq!(is("foo")(&mut input), Ok("foo"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn non_consuming_fail_does_not_consume() {
	let tokens = vec!["hallo"];
	let mut input = Input::new(tokens);
	let parser = is("hello");
	let output = attempt(&parser)(&mut input);
	assert_eq!(output, Err(Error::UnexpectedToken));
	// Input should still be intact.
	assert_eq!(input.next_token(), Some("hallo"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn consuming_fail_does_not_consume() {
	let tokens = vec!["hello", "world"];
	let mut input = Input::new(tokens);
	let consuming_parser = |input: &mut Input<_>| {
		let o1 = is("hello")(input)?; // Success, consumes "hello".
		let o2 = is("hillo")(input)?; // Fails on "world", consuming parser fails.
		Ok((o1, o2))
	};
	let output = attempt(&consuming_parser)(&mut input);
	assert_eq!(output, Err(Error::UnexpectedToken));
	// Input should be rewound even though the inner parser consumed.
	assert_eq!(input.next_token(), Some("hello"));
	assert_eq!(input.next_token(), Some("world"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn attempt_twice() {
	let tokens = vec!["hello", "world"];
	let mut input = Input::new(tokens);
	let parser = is("hello");
	let first = attempt(&parser)(&mut input);
	assert_eq!(first, Ok("hello"));
	// First attempt consumed "hello".
	let second = attempt(&parser)(&mut input);
	assert_eq!(second, Err(Error::UnexpectedToken));
	// Input should still have "world".
	assert_eq!(input.next_token(), Some("world"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn attempt_with_option_succeeds_consuming() {
	let tokens = vec!["hello", "world", "hillo"];
	let mut input = Input::new(tokens);
	let parser1 = is("hello");
	let parser2 = is("world");
	let parser_attempt = attempt(&parser1);
	let parser = option(&parser_attempt, &parser2);
	let output = attempt(&parser)(&mut input);
	// Input was consumed because the first argument of `option` succeeded.
	assert_eq!(output, Ok("hello"));
	assert_eq!(input.next_token(), Some("world"));
	assert_eq!(input.next_token(), Some("hillo"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn attempt_with_option_fails_not_consuming() {
	let tokens = vec!["hello", "world", "hillo"];
	let mut input = Input::new(tokens);
	let parser2 = is("world");
	let parser3 = is("hillo");
	let parser_attempt_1 = attempt(&parser2);
	let parser = option(&parser_attempt_1, &parser3);
	let output = attempt(&parser)(&mut input);
	assert_eq!(output, Err(Error::UnexpectedToken));
	// No input was consumed thanks to `attempt`.
	assert_eq!(input.next_token(), Some("hello"));
	assert_eq!(input.next_token(), Some("world"));
	assert_eq!(input.next_token(), Some("hillo"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn attempt_with_option_on_consuming_parser_succeeds_consuming() {
	let tokens = vec!["hello", "world", "hillo"];
	let mut input = Input::new(tokens);
	// Create two parsers that share a prefix.
	let parser1 = is("hello");
	let parser2 = is("world");
	let parser3 = is("hillo");
	let parser13 = |input: &mut Input<_>| {
		let o1 = parser1(input)?;
		let o2 = parser3(input)?;
		Ok((o1, o2))
	};
	let parser12 = |input: &mut Input<_>| {
		let o1 = parser1(input)?;
		let o2 = parser2(input)?;
		Ok((o1, o2))
	};
	// Use `option` while the first uses `attempt`.
	let parser_attempt_1 = attempt(&parser13);
	let parser = option(&parser_attempt_1, &parser12);
	let output = parser(&mut input);
	// Even though the first parser failed consuming input, `option` succeeded because `attempt`
	// implements arbitrary lookahead and conserved input.
	assert_eq!(output, Ok(("hello", "world")));
	assert_eq!(input.next_token(), Some("hillo"));
	assert!(end_of_input()(&mut input).is_ok());
}

#[test]
fn attempt_without_option_on_consuming_parser_fails_not_consuming() {
	let tokens = vec!["hello", "world", "hillo"];
	let mut input = Input::new(tokens);
	// Create two parsers that share a prefix.
	let parser1 = is("hello");
	let parser2 = is("world");
	let parser3 = is("hillo");
	let parser13 = |input: &mut Input<_>| {
		let o1 = parser1(input)?;
		let o2 = parser3(input)?;
		Ok((o1, o2))
	};
	let parser12 = |input: &mut Input<_>| {
		let o1 = parser1(input)?;
		let o2 = parser2(input)?;
		Ok((o1, o2))
	};
	// Use `option` while the first does NOT use `attempt`.
	let parser = option(&parser13, &parser12);
	let output = attempt(&parser)(&mut input);
	// The first parser failed consuming input and `attempt` was not used, so the input was
	// consumed, and `option`'s second operand failed.
	assert_eq!(output, Err(Error::UnexpectedToken));
	assert_eq!(input.next_token(), Some("hello"));
	assert_eq!(input.next_token(), Some("world"));
	assert_eq!(input.next_token(), Some("hillo"));
	assert!(end_of_input()(&mut input).is_ok());
}