#![allow(unused_imports)]
#[cfg(feature = "alloc")]
use crate::lib::std::boxed::Box;
use crate::error::{ErrorKind, FromExternalError, ParseError};
use crate::input::IntoOutput;
use crate::input::{AsChar, InputIter, InputLength, InputTakeAtPosition, Location, ParseTo};
use crate::input::{Compare, CompareResult, Offset, Slice};
use crate::lib::std::borrow::Borrow;
use crate::lib::std::convert;
#[cfg(feature = "std")]
use crate::lib::std::fmt::Debug;
use crate::lib::std::mem::transmute;
use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
use crate::IntoOutputIResult;
use crate::*;
#[cfg(test)]
mod tests;
#[inline]
pub fn rest<T, E: ParseError<T>>(input: T) -> IResult<T, <T as IntoOutput>::Output, E>
where
T: Slice<RangeFrom<usize>>,
T: InputLength,
T: IntoOutput,
{
Ok((input.slice(input.input_len()..), input)).into_output()
}
#[inline]
pub fn rest_len<T, E: ParseError<T>>(input: T) -> IResult<T, usize, E>
where
T: InputLength,
{
let len = input.input_len();
Ok((input, len))
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct ByRef<'p, P> {
p: &'p mut P,
}
impl<'p, P> ByRef<'p, P> {
pub(crate) fn new(p: &'p mut P) -> Self {
Self { p }
}
}
impl<'p, I, O, E, P: Parser<I, O, E>> Parser<I, O, E> for ByRef<'p, P> {
fn parse(&mut self, i: I) -> IResult<I, O, E> {
self.p.parse(i)
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::map")]
pub fn map<I, O1, O2, E, F, G>(mut parser: F, mut f: G) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
G: FnMut(O1) -> O2,
{
move |input: I| {
let (input, o1) = parser.parse(input)?;
Ok((input, f(o1)))
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Map<F, G, O1> {
f: F,
g: G,
phantom: core::marker::PhantomData<O1>,
}
impl<F, G, O1> Map<F, G, O1> {
pub(crate) fn new(f: F, g: G) -> Self {
Self {
f,
g,
phantom: Default::default(),
}
}
}
impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> O2> Parser<I, O2, E> for Map<F, G, O1> {
fn parse(&mut self, i: I) -> IResult<I, O2, E> {
match self.f.parse(i) {
Err(e) => Err(e),
Ok((i, o)) => Ok((i, (self.g)(o))),
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::map_res")]
pub fn map_res<I: Clone, O1, O2, E: FromExternalError<I, E2>, E2, F, G>(
mut parser: F,
mut f: G,
) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
G: FnMut(O1) -> Result<O2, E2>,
{
move |input: I| {
let i = input.clone();
let (input, o1) = parser.parse(input)?;
match f(o1) {
Ok(o2) => Ok((input, o2)),
Err(e) => Err(Err::Error(E::from_external_error(i, ErrorKind::MapRes, e))),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct MapRes<F, G, O1> {
f: F,
g: G,
phantom: core::marker::PhantomData<O1>,
}
impl<F, G, O1> MapRes<F, G, O1> {
pub(crate) fn new(f: F, g: G) -> Self {
Self {
f,
g,
phantom: Default::default(),
}
}
}
impl<I, O1, O2, E, E2, F, G> Parser<I, O2, E> for MapRes<F, G, O1>
where
I: Clone,
F: Parser<I, O1, E>,
G: FnMut(O1) -> Result<O2, E2>,
E: FromExternalError<I, E2>,
{
fn parse(&mut self, input: I) -> IResult<I, O2, E> {
let i = input.clone();
let (input, o1) = self.f.parse(input)?;
match (self.g)(o1) {
Ok(o2) => Ok((input, o2)),
Err(e) => Err(Err::Error(E::from_external_error(i, ErrorKind::MapRes, e))),
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::map_res")]
pub fn map_opt<I: Clone, O1, O2, E: ParseError<I>, F, G>(
mut parser: F,
mut f: G,
) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
G: FnMut(O1) -> Option<O2>,
{
move |input: I| {
let i = input.clone();
let (input, o1) = parser.parse(input)?;
match f(o1) {
Some(o2) => Ok((input, o2)),
None => Err(Err::Error(E::from_error_kind(i, ErrorKind::MapOpt))),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct MapOpt<F, G, O1> {
f: F,
g: G,
phantom: core::marker::PhantomData<O1>,
}
impl<F, G, O1> MapOpt<F, G, O1> {
pub(crate) fn new(f: F, g: G) -> Self {
Self {
f,
g,
phantom: Default::default(),
}
}
}
impl<I, O1, O2, E, F, G> Parser<I, O2, E> for MapOpt<F, G, O1>
where
I: Clone,
F: Parser<I, O1, E>,
G: FnMut(O1) -> Option<O2>,
E: ParseError<I>,
{
fn parse(&mut self, input: I) -> IResult<I, O2, E> {
let i = input.clone();
let (input, o1) = self.f.parse(input)?;
match (self.g)(o1) {
Some(o2) => Ok((input, o2)),
None => Err(Err::Error(E::from_error_kind(i, ErrorKind::MapOpt))),
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::and_then")]
pub fn map_parser<I, O1, O2, E: ParseError<I>, F, G>(
mut parser: F,
mut applied_parser: G,
) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
G: Parser<O1, O2, E>,
{
move |input: I| {
let (input, o1) = parser.parse(input)?;
let (_, o2) = applied_parser.parse(o1)?;
Ok((input, o2))
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct AndThen<F, G, O1> {
f: F,
g: G,
phantom: core::marker::PhantomData<O1>,
}
impl<F, G, O1> AndThen<F, G, O1> {
pub(crate) fn new(f: F, g: G) -> Self {
Self {
f,
g,
phantom: Default::default(),
}
}
}
impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<O1, O2, E>> Parser<I, O2, E>
for AndThen<F, G, O1>
{
fn parse(&mut self, i: I) -> IResult<I, O2, E> {
let (i, o1) = self.f.parse(i)?;
let (_, o2) = self.g.parse(o1)?;
Ok((i, o2))
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::flat_map")]
pub fn flat_map<I, O1, O2, E: ParseError<I>, F, G, H>(
mut parser: F,
mut applied_parser: G,
) -> impl FnMut(I) -> IResult<I, O2, E>
where
F: Parser<I, O1, E>,
G: FnMut(O1) -> H,
H: Parser<I, O2, E>,
{
move |input: I| {
let (input, o1) = parser.parse(input)?;
applied_parser(o1).parse(input)
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct FlatMap<F, G, O1> {
f: F,
g: G,
phantom: core::marker::PhantomData<O1>,
}
impl<F, G, O1> FlatMap<F, G, O1> {
pub(crate) fn new(f: F, g: G) -> Self {
Self {
f,
g,
phantom: Default::default(),
}
}
}
impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> H, H: Parser<I, O2, E>> Parser<I, O2, E>
for FlatMap<F, G, O1>
{
fn parse(&mut self, i: I) -> IResult<I, O2, E> {
let (i, o1) = self.f.parse(i)?;
(self.g)(o1).parse(i)
}
}
pub fn opt<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Option<O>, E>
where
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match f.parse(input) {
Ok((i, o)) => Ok((i, Some(o))),
Err(Err::Error(_)) => Ok((i, None)),
Err(e) => Err(e),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct And<F, G> {
f: F,
g: G,
}
impl<F, G> And<F, G> {
pub(crate) fn new(f: F, g: G) -> Self {
Self { f, g }
}
}
impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<I, O2, E>> Parser<I, (O1, O2), E>
for And<F, G>
{
fn parse(&mut self, i: I) -> IResult<I, (O1, O2), E> {
let (i, o1) = self.f.parse(i)?;
let (i, o2) = self.g.parse(i)?;
Ok((i, (o1, o2)))
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Or<F, G> {
f: F,
g: G,
}
impl<F, G> Or<F, G> {
pub(crate) fn new(f: F, g: G) -> Self {
Self { f, g }
}
}
impl<'a, I: Clone, O, E: crate::error::ParseError<I>, F: Parser<I, O, E>, G: Parser<I, O, E>>
Parser<I, O, E> for Or<F, G>
{
fn parse(&mut self, i: I) -> IResult<I, O, E> {
match self.f.parse(i.clone()) {
Err(Err::Error(e1)) => match self.g.parse(i) {
Err(Err::Error(e2)) => Err(Err::Error(e1.or(e2))),
res => res,
},
res => res,
}
}
}
pub fn cond<I, O, E: ParseError<I>, F>(
b: bool,
mut f: F,
) -> impl FnMut(I) -> IResult<I, Option<O>, E>
where
F: Parser<I, O, E>,
{
move |input: I| {
if b {
match f.parse(input) {
Ok((i, o)) => Ok((i, Some(o))),
Err(e) => Err(e),
}
} else {
Ok((input, None))
}
}
}
pub fn peek<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
where
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match f.parse(input) {
Ok((_, o)) => Ok((i, o)),
Err(e) => Err(e),
}
}
}
pub fn eof<I, E: ParseError<I>>(input: I) -> IResult<I, <I as IntoOutput>::Output, E>
where
I: InputLength,
I: Clone,
I: IntoOutput,
{
if input.input_len() == 0 {
let clone = input.clone();
Ok((input, clone)).into_output()
} else {
Err(Err::Error(E::from_error_kind(input, ErrorKind::Eof)))
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::complete")]
pub fn complete<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
where
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match f.parse(input) {
Err(Err::Incomplete(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Complete))),
rest => rest,
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Complete<F> {
f: F,
}
impl<F> Complete<F> {
pub(crate) fn new(f: F) -> Self {
Self { f }
}
}
impl<F, I, O, E> Parser<I, O, E> for Complete<F>
where
I: Clone,
F: Parser<I, O, E>,
E: ParseError<I>,
{
fn parse(&mut self, input: I) -> IResult<I, O, E> {
let i = input.clone();
match (self.f).parse(input) {
Err(Err::Incomplete(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Complete))),
rest => rest,
}
}
}
pub fn all_consuming<I, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
where
I: InputLength,
F: Parser<I, O, E>,
{
move |input: I| {
let (input, res) = f.parse(input)?;
if input.input_len() == 0 {
Ok((input, res))
} else {
Err(Err::Error(E::from_error_kind(input, ErrorKind::Eof)))
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::verify")]
pub fn verify<I: Clone, O1, O2, E: ParseError<I>, F, G>(
mut first: F,
second: G,
) -> impl FnMut(I) -> IResult<I, O1, E>
where
F: Parser<I, O1, E>,
G: Fn(&O2) -> bool,
O1: Borrow<O2>,
O2: ?Sized,
{
move |input: I| {
let i = input.clone();
let (input, o) = first.parse(input)?;
if second(o.borrow()) {
Ok((input, o))
} else {
Err(Err::Error(E::from_error_kind(i, ErrorKind::Verify)))
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Verify<F, G, O2: ?Sized> {
first: F,
second: G,
phantom: core::marker::PhantomData<O2>,
}
impl<F, G, O2: ?Sized> Verify<F, G, O2> {
pub(crate) fn new(first: F, second: G) -> Self {
Self {
first,
second,
phantom: Default::default(),
}
}
}
impl<I, O1, O2, E, F: Parser<I, O1, E>, G> Parser<I, O1, E> for Verify<F, G, O2>
where
I: Clone,
E: ParseError<I>,
F: Parser<I, O1, E>,
G: Fn(&O2) -> bool,
O1: Borrow<O2>,
O2: ?Sized,
{
fn parse(&mut self, input: I) -> IResult<I, O1, E> {
let i = input.clone();
let (input, o) = (self.first).parse(input)?;
if (self.second)(o.borrow()) {
Ok((input, o))
} else {
Err(Err::Error(E::from_error_kind(i, ErrorKind::Verify)))
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::value")]
pub fn value<I, O1: Clone, O2, E: ParseError<I>, F>(
val: O1,
mut parser: F,
) -> impl FnMut(I) -> IResult<I, O1, E>
where
F: Parser<I, O2, E>,
{
move |input: I| parser.parse(input).map(|(i, _)| (i, val.clone()))
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Value<F, O1, O2> {
parser: F,
val: O2,
phantom: core::marker::PhantomData<O1>,
}
impl<F, O1, O2> Value<F, O1, O2> {
pub(crate) fn new(parser: F, val: O2) -> Self {
Self {
parser,
val,
phantom: Default::default(),
}
}
}
impl<I, O1, O2: Clone, E: ParseError<I>, F: Parser<I, O1, E>> Parser<I, O2, E>
for Value<F, O1, O2>
{
fn parse(&mut self, input: I) -> IResult<I, O2, E> {
(self.parser)
.parse(input)
.map(|(i, _)| (i, self.val.clone()))
}
}
pub fn not<I: Clone, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, (), E>
where
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match parser.parse(input) {
Ok(_) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Not))),
Err(Err::Error(_)) => Ok((i, ())),
Err(e) => Err(e),
}
}
}
#[deprecated(since = "8.0.0", note = "Replaced with `Parser::recognize")]
pub fn recognize<I, O, E: ParseError<I>, F>(
mut parser: F,
) -> impl FnMut(I) -> IResult<I, <I as IntoOutput>::Output, E>
where
I: Clone,
I: Offset,
I: Slice<RangeTo<usize>>,
I: IntoOutput,
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match parser.parse(i) {
Ok((i, _)) => {
let index = input.offset(&i);
Ok((i, input.slice(..index))).into_output()
}
Err(e) => Err(e),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Recognize<F, O> {
parser: F,
o: core::marker::PhantomData<O>,
}
impl<F, O> Recognize<F, O> {
pub(crate) fn new(parser: F) -> Self {
Self {
parser,
o: Default::default(),
}
}
}
impl<I, O, E, F> Parser<I, <I as IntoOutput>::Output, E> for Recognize<F, O>
where
I: Clone,
I: Offset,
I: Slice<RangeTo<usize>>,
I: IntoOutput,
E: ParseError<I>,
F: Parser<I, O, E>,
{
fn parse(&mut self, input: I) -> IResult<I, <I as IntoOutput>::Output, E> {
let i = input.clone();
match (self.parser).parse(i) {
Ok((i, _)) => {
let index = input.offset(&i);
Ok((i, input.slice(..index))).into_output()
}
Err(e) => Err(e),
}
}
}
#[deprecated(
since = "8.0.0",
note = "Replaced with `Parser::with_recognized (output ordering is changed)"
)]
pub fn consumed<I, O, F, E>(
mut parser: F,
) -> impl FnMut(I) -> IResult<I, (<I as IntoOutput>::Output, O), E>
where
I: Clone + Offset + Slice<RangeTo<usize>>,
I: IntoOutput,
E: ParseError<I>,
F: Parser<I, O, E>,
{
move |input: I| {
let i = input.clone();
match parser.parse(i) {
Ok((remaining, result)) => {
let index = input.offset(&remaining);
let consumed = input.slice(..index).into_output();
Ok((remaining, (consumed, result)))
}
Err(e) => Err(e),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct WithRecognized<F, O> {
parser: F,
o: core::marker::PhantomData<O>,
}
impl<F, O> WithRecognized<F, O> {
pub(crate) fn new(parser: F) -> Self {
Self {
parser,
o: Default::default(),
}
}
}
impl<I, O, E, F> Parser<I, (O, <I as IntoOutput>::Output), E> for WithRecognized<F, O>
where
I: Clone,
I: Offset,
I: Slice<RangeTo<usize>>,
I: IntoOutput,
E: ParseError<I>,
F: Parser<I, O, E>,
{
fn parse(&mut self, input: I) -> IResult<I, (O, <I as IntoOutput>::Output), E> {
let i = input.clone();
match (self.parser).parse(i) {
Ok((remaining, result)) => {
let index = input.offset(&remaining);
let consumed = input.slice(..index).into_output();
Ok((remaining, (result, consumed)))
}
Err(e) => Err(e),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct Span<F, O> {
parser: F,
o: core::marker::PhantomData<O>,
}
impl<F, O> Span<F, O> {
pub(crate) fn new(parser: F) -> Self {
Self {
parser,
o: Default::default(),
}
}
}
impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, O>
where
I: Clone + Location,
E: ParseError<I>,
F: Parser<I, O, E>,
{
fn parse(&mut self, input: I) -> IResult<I, Range<usize>, E> {
let start = input.location();
self.parser.parse(input).map(move |(remaining, _)| {
let end = remaining.location();
(remaining, (start..end))
})
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct WithSpan<F, O> {
parser: F,
o: core::marker::PhantomData<O>,
}
impl<F, O> WithSpan<F, O> {
pub(crate) fn new(parser: F) -> Self {
Self {
parser,
o: Default::default(),
}
}
}
impl<I, O, E, F> Parser<I, (O, Range<usize>), E> for WithSpan<F, O>
where
I: Clone + Location,
E: ParseError<I>,
F: Parser<I, O, E>,
{
fn parse(&mut self, input: I) -> IResult<I, (O, Range<usize>), E> {
let start = input.location();
self.parser.parse(input).map(move |(remaining, output)| {
let end = remaining.location();
(remaining, (output, (start..end)))
})
}
}
pub fn cut<I, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, O, E>
where
F: Parser<I, O, E>,
{
move |input: I| match parser.parse(input) {
Err(Err::Error(e)) => Err(Err::Failure(e)),
rest => rest,
}
}
#[deprecated(
since = "8.0.0",
note = "Replaced with `Parser::output_into` and `Parser::err_into`"
)]
pub fn into<I, O1, O2, E1, E2, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, O2, E2>
where
O1: convert::Into<O2>,
E1: convert::Into<E2>,
E1: ParseError<I>,
E2: ParseError<I>,
F: Parser<I, O1, E1>,
{
move |input: I| match parser.parse(input) {
Ok((i, o)) => Ok((i, o.into())),
Err(Err::Error(e)) => Err(Err::Error(e.into())),
Err(Err::Failure(e)) => Err(Err::Failure(e.into())),
Err(Err::Incomplete(e)) => Err(Err::Incomplete(e)),
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct OutputInto<F, O1, O2: From<O1>> {
f: F,
phantom_out1: core::marker::PhantomData<O1>,
phantom_out2: core::marker::PhantomData<O2>,
}
impl<F, O1, O2: From<O1>> OutputInto<F, O1, O2> {
pub(crate) fn new(f: F) -> Self {
Self {
f,
phantom_out1: Default::default(),
phantom_out2: Default::default(),
}
}
}
impl<'a, I: Clone, O1, O2: From<O1>, E, F: Parser<I, O1, E>> Parser<I, O2, E>
for OutputInto<F, O1, O2>
{
fn parse(&mut self, i: I) -> IResult<I, O2, E> {
match self.f.parse(i) {
Ok((i, o)) => Ok((i, o.into())),
Err(err) => Err(err),
}
}
}
#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
pub struct ErrInto<F, E1, E2: From<E1>> {
f: F,
phantom_err1: core::marker::PhantomData<E1>,
phantom_err2: core::marker::PhantomData<E2>,
}
impl<F, E1, E2: From<E1>> ErrInto<F, E1, E2> {
pub(crate) fn new(f: F) -> Self {
Self {
f,
phantom_err1: Default::default(),
phantom_err2: Default::default(),
}
}
}
impl<'a, I: Clone, O, E1, E2: crate::error::ParseError<I> + From<E1>, F: Parser<I, O, E1>>
Parser<I, O, E2> for ErrInto<F, E1, E2>
{
fn parse(&mut self, i: I) -> IResult<I, O, E2> {
match self.f.parse(i) {
Ok(ok) => Ok(ok),
Err(Err::Error(e)) => Err(Err::Error(e.into())),
Err(Err::Failure(e)) => Err(Err::Failure(e.into())),
Err(Err::Incomplete(e)) => Err(Err::Incomplete(e)),
}
}
}
pub fn iterator<Input, Output, Error, F>(
input: Input,
f: F,
) -> ParserIterator<Input, Output, Error, F>
where
F: Parser<Input, Output, Error>,
Error: ParseError<Input>,
{
ParserIterator {
iterator: f,
input,
output: Default::default(),
state: Some(State::Running),
}
}
pub struct ParserIterator<I, O, E, F> {
iterator: F,
input: I,
output: core::marker::PhantomData<O>,
state: Option<State<E>>,
}
impl<I: Clone, O, E, F> ParserIterator<I, O, E, F> {
pub fn finish(mut self) -> IResult<I, (), E> {
match self.state.take().unwrap() {
State::Running | State::Done => Ok((self.input, ())),
State::Failure(e) => Err(Err::Failure(e)),
State::Incomplete(i) => Err(Err::Incomplete(i)),
}
}
}
impl<'a, Input, Output, Error, F> core::iter::Iterator
for &'a mut ParserIterator<Input, Output, Error, F>
where
F: Parser<Input, Output, Error>,
Input: Clone,
{
type Item = Output;
fn next(&mut self) -> Option<Self::Item> {
if let State::Running = self.state.take().unwrap() {
let input = self.input.clone();
match self.iterator.parse(input) {
Ok((i, o)) => {
self.input = i;
self.state = Some(State::Running);
Some(o)
}
Err(Err::Error(_)) => {
self.state = Some(State::Done);
None
}
Err(Err::Failure(e)) => {
self.state = Some(State::Failure(e));
None
}
Err(Err::Incomplete(i)) => {
self.state = Some(State::Incomplete(i));
None
}
}
} else {
None
}
}
}
enum State<E> {
Running,
Done,
Failure(E),
Incomplete(Needed),
}
pub fn success<I, O: Clone, E: ParseError<I>>(val: O) -> impl Fn(I) -> IResult<I, O, E> {
move |input: I| Ok((input, val.clone()))
}
pub fn fail<I, O, E: ParseError<I>>(i: I) -> IResult<I, O, E> {
Err(Err::Error(E::from_error_kind(i, ErrorKind::Fail)))
}