159 lines
4.0 KiB
Rust
159 lines
4.0 KiB
Rust
use crate::parser::{ParseResult, Parser};
|
|
|
|
pub fn choice2<P1, P2, I, O, E>(parser1: P1, parser2: P2) -> impl Parser<I, O, E>
|
|
where
|
|
P1: Parser<I, O, E>,
|
|
P2: Parser<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
move |input: I| match parser1.parse(input.clone()) {
|
|
ok @ Ok(..) => ok,
|
|
Err(_e) => parser2.parse(input),
|
|
}
|
|
}
|
|
|
|
pub fn choice<C, I, O, E>(choices: C) -> impl Parser<I, O, E>
|
|
where
|
|
C: Choice<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
move |input| choices.parse(input)
|
|
}
|
|
|
|
pub trait Choice<I: Clone, O, E> {
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E>;
|
|
}
|
|
|
|
impl<I, O, E, P1, P2> Choice<I, O, E> for (P1, P2)
|
|
where
|
|
P1: Parser<I, O, E>,
|
|
P2: Parser<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E> {
|
|
let parser1 = &self.0;
|
|
let parser2 = &self.1;
|
|
|
|
//TODO need a more principled way to return an error when no choices work
|
|
let mut err = None;
|
|
|
|
for parser in [parser1 as &dyn Parser<I, O, E>, parser2].iter() {
|
|
match parser.parse(input.clone()) {
|
|
Ok(result) => return Ok(result),
|
|
Err(e) => {
|
|
err = Some(e);
|
|
}
|
|
}
|
|
}
|
|
Err(err.unwrap())
|
|
}
|
|
}
|
|
|
|
impl<I, O, E, P1, P2, P3> Choice<I, O, E> for (P1, P2, P3)
|
|
where
|
|
P1: Parser<I, O, E>,
|
|
P2: Parser<I, O, E>,
|
|
P3: Parser<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E> {
|
|
let parser1 = &self.0;
|
|
let parser2 = &self.1;
|
|
let parser3 = &self.2;
|
|
|
|
//TODO need a more principled way to return an error when no choices work
|
|
let mut err = None;
|
|
|
|
for parser in [parser1 as &dyn Parser<I, O, E>, parser2, parser3].iter() {
|
|
match parser.parse(input.clone()) {
|
|
Ok(result) => return Ok(result),
|
|
Err(e) => {
|
|
err = Some(e);
|
|
}
|
|
}
|
|
}
|
|
Err(err.unwrap())
|
|
}
|
|
}
|
|
|
|
impl<I, O, E, P1, P2, P3, P4> Choice<I, O, E> for (P1, P2, P3, P4)
|
|
where
|
|
P1: Parser<I, O, E>,
|
|
P2: Parser<I, O, E>,
|
|
P3: Parser<I, O, E>,
|
|
P4: Parser<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E> {
|
|
let parser1 = &self.0;
|
|
let parser2 = &self.1;
|
|
let parser3 = &self.2;
|
|
let parser4 = &self.3;
|
|
|
|
//TODO need a more principled way to return an error when no choices work
|
|
let mut err = None;
|
|
|
|
for parser in [parser1 as &dyn Parser<I, O, E>, parser2, parser3, parser4].iter() {
|
|
match parser.parse(input.clone()) {
|
|
Ok(result) => return Ok(result),
|
|
Err(e) => {
|
|
err = Some(e);
|
|
}
|
|
}
|
|
}
|
|
Err(err.unwrap())
|
|
}
|
|
}
|
|
|
|
impl<I, O, E, P1, P2, P3, P4, P5> Choice<I, O, E> for (P1, P2, P3, P4, P5)
|
|
where
|
|
P1: Parser<I, O, E>,
|
|
P2: Parser<I, O, E>,
|
|
P3: Parser<I, O, E>,
|
|
P4: Parser<I, O, E>,
|
|
P5: Parser<I, O, E>,
|
|
I: Clone,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E> {
|
|
let parser1 = &self.0;
|
|
let parser2 = &self.1;
|
|
let parser3 = &self.2;
|
|
let parser4 = &self.3;
|
|
let parser5 = &self.4;
|
|
|
|
//TODO need a more principled way to return an error when no choices work
|
|
let mut err = None;
|
|
|
|
for parser in [
|
|
parser1 as &dyn Parser<I, O, E>,
|
|
parser2,
|
|
parser3,
|
|
parser4,
|
|
parser5,
|
|
]
|
|
.iter()
|
|
{
|
|
match parser.parse(input.clone()) {
|
|
Ok(result) => return Ok(result),
|
|
Err(e) => {
|
|
err = Some(e);
|
|
}
|
|
}
|
|
}
|
|
Err(err.unwrap())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::combinators::one_or_more;
|
|
use crate::primitives::literal;
|
|
|
|
#[test]
|
|
fn test_choice() {
|
|
let p = choice2(literal("gnostika").to(1), one_or_more(literal(" ")).to(2));
|
|
assert_eq!(p.parse("gnostika twentynine"), Ok((1, " twentynine")));
|
|
}
|
|
}
|