[WIP] Feature multi range

examples/s_expression.rs

@@ -13,7 +13,7 @@ use nom::{
   character::complete::{alpha1, char, digit1, multispace0, multispace1, one_of},
   combinator::{cut, map, map_res, opt},
   error::{context, VerboseError},
-  multi::many0,
+  multi::many,
   sequence::{delimited, preceded, terminated, tuple},
   IResult, Parser,
 };
@@ -176,7 +176,7 @@ where
 /// `tuple` is used to sequence parsers together, so we can translate this directly
 /// and then map over it to transform the output into an `Expr::Application`
 fn parse_application<'a>(i: &'a str) -> IResult<&'a str, Expr, VerboseError<&'a str>> {
-  let application_inner = map(tuple((parse_expr, many0(parse_expr))), |(head, tail)| {
+  let application_inner = map(tuple((parse_expr, many(0.., parse_expr))), |(head, tail)| {
     Expr::Application(Box::new(head), tail)
   });
   // finally, we wrap it in an s-expression
@@ -226,7 +226,7 @@ fn parse_quote<'a>(i: &'a str) -> IResult<&'a str, Expr, VerboseError<&'a str>>
   // we find the `'` (quote) character, use cut to say that we're unambiguously
   // looking for an s-expression of 0 or more expressions, and then parse them
   map(
-    context("quote", preceded(tag("'"), cut(s_exp(many0(parse_expr))))),
+    context("quote", preceded(tag("'"), cut(s_exp(many(0.., parse_expr))))),
     |exprs| Expr::Quote(exprs),
   )(i)
 }

examples/string.rs

@@ -19,7 +19,7 @@ use nom::bytes::streaming::{is_not, take_while_m_n};
 use nom::character::streaming::{char, multispace1};
 use nom::combinator::{map, map_opt, map_res, value, verify};
 use nom::error::{FromExternalError, ParseError};
-use nom::multi::fold_many0;
+use nom::multi::fold;
 use nom::sequence::{delimited, preceded};
 use nom::IResult;
 
@@ -139,9 +139,10 @@ fn parse_string<'a, E>(input: &'a str) -> IResult<&'a str, String, E>
 where
   E: ParseError<&'a str> + FromExternalError<&'a str, std::num::ParseIntError>,
 {
-  // fold_many0 is the equivalent of iterator::fold. It runs a parser in a loop,
+  // fold is the equivalent of iterator::fold. It runs a parser in a loop,
   // and for each output value, calls a folding function on each output value.
-  let build_string = fold_many0(
+  let build_string = fold(
+    0..,
     // Our parser function– parses a single string fragment
     parse_fragment,
     // Our init value, an empty string
@@ -160,7 +161,7 @@ where
 
   // Finally, parse the string. Note that, if `build_string` could accept a raw
   // " character, the closing delimiter " would never match. When using
-  // `delimited` with a looping parser (like fold_many0), be sure that the
+  // `delimited` with a looping parser (like fold), be sure that the
   // loop won't accidentally match your closing delimiter!
   delimited(char('"'), build_string, char('"'))(input)
 }

src/error.rs

@@ -417,6 +417,8 @@ pub enum ErrorKind {
   Float,
   Satisfy,
   Fail,
+  Many,
+  Fold,
 }
 
 #[rustfmt::skip]
@@ -477,6 +479,8 @@ pub fn error_to_u32(e: &ErrorKind) -> u32 {
     ErrorKind::Float                     => 73,
     ErrorKind::Satisfy                   => 74,
     ErrorKind::Fail                      => 75,
+    ErrorKind::Many                      => 76,
+    ErrorKind::Fold                      => 77,
   }
 }
 
@@ -539,6 +543,8 @@ impl ErrorKind {
       ErrorKind::Float                     => "Float",
       ErrorKind::Satisfy                   => "Satisfy",
       ErrorKind::Fail                      => "Fail",
+      ErrorKind::Many                      => "Many",
+      ErrorKind::Fold                      => "Fold",
     }
   }
 }

src/multi/mod.rs

@@ -8,8 +8,9 @@ use crate::error::ParseError;
 use crate::internal::{Err, IResult, Needed, Parser};
 #[cfg(feature = "alloc")]
 use crate::lib::std::vec::Vec;
-use crate::traits::{InputLength, InputTake, ToUsize};
+use crate::traits::{InputLength, InputTake, ToUsize, IntoRangeBounds, RangeIterator};
 use core::num::NonZeroUsize;
+use core::ops::{RangeBounds, Bound};
 
 /// Repeats the embedded parser until it fails
 /// and returns the results in a `Vec`.
@@ -37,6 +38,7 @@ use core::num::NonZeroUsize;
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+#[deprecated = "Replaced with `many`"]
 pub fn many0<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
 where
   I: Clone + InputLength,
@@ -92,6 +94,7 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+#[deprecated = "Replaced with `many`"]
 pub fn many1<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
 where
   I: Clone + InputLength,
@@ -349,6 +352,7 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+#[deprecated = "Replaced with `many`"]
 pub fn many_m_n<I, O, E, F>(
   min: usize,
   max: usize,
@@ -637,6 +641,7 @@ where
 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
 /// assert_eq!(parser(""), Ok(("", vec![])));
 /// ```
+#[deprecated = "Replaced with `fold`"]
 pub fn fold_many0<I, O, E, F, G, H, R>(
   mut f: F,
   mut init: H,
@@ -708,6 +713,7 @@ where
 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));
 /// ```
+#[deprecated = "Replaced with `fold`"]
 pub fn fold_many1<I, O, E, F, G, H, R>(
   mut f: F,
   mut init: H,
@@ -792,6 +798,7 @@ where
 /// assert_eq!(parser(""), Ok(("", vec![])));
 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
 /// ```
+#[deprecated = "Replaced with `fold`"]
 pub fn fold_many_m_n<I, O, E, F, G, H, R>(
   min: usize,
   max: usize,
@@ -991,3 +998,170 @@ where
     Ok((input, res))
   }
 }
+
+/// Repeats the embedded parser and returns the results in a `Vec`.
+/// Fails if the amount of time the embedded parser is run is not
+/// within the specified range.
+/// # Arguments
+/// * `range` The amount of times to apply the parser. A range without
+/// an upper bound is the same as `(lower..=usize::MAX)`.
+/// * `parse` The parser to apply.
+/// ```rust
+/// # #[macro_use] extern crate nom;
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::many;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many(0..=2, tag("abc"))(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+#[cfg(feature = "alloc")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
+pub fn many<I, O, E, F, G, H>(
+  range: G,
+  mut parse: F,
+) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  E: ParseError<I>,
+  G: IntoRangeBounds<H>,
+  H: RangeBounds<usize>,
+{
+  let range = range.convert();
+  move |mut input: I| {
+    let start = match range.start_bound() {
+      Bound::Included(start) if !range.contains(start) => return Err(Err::Failure(E::from_error_kind(input, ErrorKind::Many))),
+      Bound::Excluded(start) if !range.contains(start) => return Err(Err::Failure(E::from_error_kind(input, ErrorKind::Many))),
+      Bound::Included(start) => Some(*start),
+      Bound::Excluded(start) => Some(*start + 1),
+      _ => None,
+    };
+
+
+    let mut res = crate::lib::std::vec::Vec::with_capacity(start.unwrap_or(0));
+
+    for count in range.bounded_iter() {
+      let len = input.input_len();
+      match parse.parse(input.clone()) {
+        Ok((tail, value)) => {
+          // infinite loop check: the parser must always consume
+          if tail.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many)));
+          }
+
+          res.push(value);
+          input = tail;
+        }
+        Err(Err::Error(e)) => {
+          if !range.contains(&count) {
+            return Err(Err::Error(E::append(input, ErrorKind::Many, e)));
+          } else {
+            return Ok((input, res));
+          }
+        }
+        Err(e) => {
+          return Err(e);
+        }
+      }
+    }
+
+    Ok((input, res))
+  }
+}
+
+/// Applies a parser and accumulates the results using a given
+/// function and initial value.
+/// Fails if the amount of time the embedded parser is run is not
+/// within the specified range.
+/// 
+/// # Arguments
+/// * `range` The amount of times to apply the parser. A range without
+/// an upper bound means the parser can run infinitely.
+/// * `parse` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `fold` The function that combines a result of `f` with
+///       the current accumulator.
+/// ```rust
+/// # #[macro_use] extern crate nom;
+/// # use nom::{Err, error::ErrorKind, Needed, IResult};
+/// use nom::multi::fold;
+/// use nom::bytes::complete::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold(
+///     0..=2,
+///     tag("abc"),
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   )(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+pub fn fold<I, O, E, F, G, H, J, K, R>(
+  range: J,
+  mut parse: F,
+  mut init: H,
+  mut fold: G,
+) -> impl FnMut(I) -> IResult<I, R, E>
+where
+  I: Clone + InputLength,
+  F: Parser<I, O, E>,
+  G: FnMut(R, O) -> R,
+  H: FnMut() -> R,
+  E: ParseError<I>,
+  J: IntoRangeBounds<K>,
+  K: RangeBounds<usize>,
+{
+  let range = range.convert();
+  move |mut input: I| {
+    match range.start_bound() {
+      Bound::Included(start) if !range.contains(start) => return Err(Err::Failure(E::from_error_kind(input, ErrorKind::Fold))),
+      Bound::Excluded(start) if !range.contains(start) => return Err(Err::Failure(E::from_error_kind(input, ErrorKind::Fold))),
+      _ => {},
+    }
+
+    let mut acc = init();
+
+    for count in range.saturating_iter() {
+      let len = input.input_len();
+      match parse.parse(input.clone()) {
+        Ok((tail, value)) => {
+          // infinite loop check: the parser must always consume
+          if tail.input_len() == len {
+            return Err(Err::Error(E::from_error_kind(tail, ErrorKind::Fold)));
+          }
+
+          acc = fold(acc, value);
+          input = tail;
+        }
+        //FInputXMError: handle failure properly
+        Err(Err::Error(err)) => {
+          if !range.contains(&count) {
+            return Err(Err::Error(E::append(input, ErrorKind::Fold, err)));
+          } else {
+            break;
+          }
+        }
+        Err(e) => return Err(e),
+      }
+    }
+
+    Ok((input, acc))
+  }
+}