103 lines
2.8 KiB
Rust
103 lines
2.8 KiB
Rust
use crate::{
|
|
representation::{Representation, EBNF},
|
|
ParseResult, Parser, ParserExtension,
|
|
};
|
|
|
|
pub fn sequence<S, I, O, E>(sequence: S) -> impl Parser<I, O, E>
|
|
where
|
|
S: Sequence<I, O, E>,
|
|
{
|
|
let repr = sequence.repr();
|
|
|
|
(move |input| -> ParseResult<I, O, E> { sequence.parse(input) })
|
|
.to_anno()
|
|
.with_repr(repr)
|
|
}
|
|
|
|
pub fn surrounded_by<I, O1, O2, E>(
|
|
main: impl Parser<I, O1, E>,
|
|
surrounding: impl Parser<I, O2, E>,
|
|
) -> impl Parser<I, O1, E> {
|
|
let s_prod = surrounding.representation().production();
|
|
let main_prod = main.representation().production();
|
|
|
|
(move |input| {
|
|
let (_result1, rest1) = surrounding.parse(input)?;
|
|
let (result2, rest2) = main.parse(rest1)?;
|
|
let (_result3, rest3) = surrounding.parse(rest2)?;
|
|
Ok((result2, rest3))
|
|
})
|
|
.to_anno()
|
|
.with_repr(Representation::new().with_production(EBNF::Sequence(vec![
|
|
s_prod.clone(),
|
|
main_prod,
|
|
s_prod,
|
|
])))
|
|
}
|
|
|
|
pub fn seq2<I, O1, O2, E>(
|
|
first: impl Parser<I, O1, E>,
|
|
second: impl Parser<I, O2, E>,
|
|
) -> impl Parser<I, (O1, O2), E> {
|
|
sequence((first, second))
|
|
}
|
|
|
|
pub trait Sequence<I, O, E> {
|
|
fn parse(&self, input: I) -> ParseResult<I, O, E>;
|
|
fn repr(&self) -> Representation;
|
|
}
|
|
|
|
impl<P1, P2, I, O1, O2, E> Sequence<I, (O1, O2), E> for (P1, P2)
|
|
where
|
|
P1: Parser<I, O1, E>,
|
|
P2: Parser<I, O2, E>,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, (O1, O2), E> {
|
|
let p1 = &self.0;
|
|
let p2 = &self.1;
|
|
p1.parse(input).and_then(|(result1, rest)| {
|
|
p2.parse(rest)
|
|
.map(|(result2, rest2)| ((result1, result2), rest2))
|
|
})
|
|
}
|
|
|
|
fn repr(&self) -> Representation {
|
|
let p1 = &self.0;
|
|
let p2 = &self.1;
|
|
Representation::new().with_production(EBNF::Sequence(vec![
|
|
p1.representation().production(),
|
|
p2.representation().production(),
|
|
]))
|
|
}
|
|
}
|
|
|
|
impl<P1, P2, P3, I, O1, O2, O3, E> Sequence<I, (O1, O2, O3), E> for (P1, P2, P3)
|
|
where
|
|
P1: Parser<I, O1, E>,
|
|
P2: Parser<I, O2, E>,
|
|
P3: Parser<I, O3, E>,
|
|
{
|
|
fn parse(&self, input: I) -> ParseResult<I, (O1, O2, O3), E> {
|
|
let p1 = &self.0;
|
|
let p2 = &self.1;
|
|
let p3 = &self.2;
|
|
|
|
let (result1, rest1) = p1.parse(input)?;
|
|
let (result2, rest2) = p2.parse(rest1)?;
|
|
let (result3, rest3) = p3.parse(rest2)?;
|
|
|
|
Ok(((result1, result2, result3), rest3))
|
|
}
|
|
|
|
fn repr(&self) -> Representation {
|
|
let p1 = &self.0;
|
|
let p2 = &self.1;
|
|
let p3 = &self.2;
|
|
Representation::new().with_production(EBNF::Sequence(vec![
|
|
p1.representation().production(),
|
|
p2.representation().production(),
|
|
p3.representation().production(),
|
|
]))
|
|
}
|
|
}
|