78 lines
1.9 KiB
Rust
78 lines
1.9 KiB
Rust
#![allow(dead_code)] //TODO eventually turn this off
|
|
mod choice;
|
|
mod combinators;
|
|
mod map;
|
|
mod primitives;
|
|
mod sequence;
|
|
|
|
pub use choice::*;
|
|
pub use combinators::*;
|
|
pub use map::*;
|
|
pub use primitives::*;
|
|
pub use sequence::*;
|
|
|
|
type ParseResult<I, O, E> = Result<(O, I), E>;
|
|
|
|
pub trait Parser<I, O, E> {
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E>;
|
|
}
|
|
|
|
impl<I, O, E, F> Parser<I, O, E> for F
|
|
where
|
|
F: Fn(I) -> ParseResult<I, O, E>,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E> {
|
|
self(input)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parsing() {
|
|
let (parsed, rest) = literal("a")("a yolo").unwrap();
|
|
assert_eq!(parsed, "a");
|
|
assert_eq!(rest, " yolo");
|
|
}
|
|
|
|
#[test]
|
|
fn test_sequence() {
|
|
let parser = sequence(literal("bongo"), sequence(literal(" "), literal("jonzzz")));
|
|
let output = parser.parse("bongo jonzzz").unwrap();
|
|
assert_eq!(output.0 .0, "bongo");
|
|
assert_eq!(output.0 .1, (" ", "jonzzz"));
|
|
assert_eq!(output.1, "");
|
|
}
|
|
|
|
#[test]
|
|
fn test_choice() {
|
|
let a = literal("bongo");
|
|
let b = literal("sucy");
|
|
let c = literal("ara");
|
|
let inputs = [&a as &dyn Parser<&str, &str, &str>, &b, &c];
|
|
let parser = choice(&inputs);
|
|
|
|
let output = parser.parse("ara hajimete").unwrap();
|
|
assert_eq!(("ara", " hajimete"), output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_map() {
|
|
let parser = map(
|
|
sequence(literal("a"), literal("b")),
|
|
|(_a, _b): (&str, &str)| 59,
|
|
);
|
|
let output = parser.parse("abcd").unwrap();
|
|
assert_eq!((59, "cd"), output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_combinators() {
|
|
let parser = sequence(map(repeated(literal_char('a')), |_| 10), literal_char('b'));
|
|
let output = parser.parse("aaaaaaaabcd").unwrap();
|
|
assert_eq! {((10, 'b'), "cd"), output};
|
|
}
|
|
}
|