Merge pull request #132 from epage/zero

fix!: Consistently apply `0` suffix to parsers

examples/ini/parser.rs

@@ -3,7 +3,7 @@ use std::str;
 
 use winnow::prelude::*;
 use winnow::{
-  bytes::take_while,
+  bytes::take_while0,
   character::{alphanumeric1 as alphanumeric, multispace0 as multispace, space0 as space},
   combinator::opt,
   multi::many0,
@@ -22,18 +22,18 @@ pub fn categories(i: Input<'_>) -> IResult<Input<'_>, HashMap<&str, HashMap<&str
 }
 
 fn category(i: Input<'_>) -> IResult<Input<'_>, &str> {
-  delimited('[', take_while(|c| c != b']'), ']')
+  delimited('[', take_while0(|c| c != b']'), ']')
     .map_res(str::from_utf8)
     .parse_next(i)
 }
 
 pub fn key_value(i: Input<'_>) -> IResult<Input<'_>, (&str, &str)> {
   let (i, key) = alphanumeric.map_res(str::from_utf8).parse_next(i)?;
   let (i, _) = (opt(space), '=', opt(space)).parse_next(i)?;
-  let (i, val) = take_while(|c| c != b'\n' && c != b';')
+  let (i, val) = take_while0(|c| c != b'\n' && c != b';')
     .map_res(str::from_utf8)
     .parse_next(i)?;
-  let (i, _) = opt((';', take_while(|c| c != b'\n')))(i)?;
+  let (i, _) = opt((';', take_while0(|c| c != b'\n')))(i)?;
   Ok((i, (key, val)))
 }
 

examples/ini/parser_str.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use winnow::prelude::*;
 use winnow::{
-  bytes::{take_till, take_while, take_while1},
+  bytes::{take_till0, take_while0, take_while1},
   character::{alphanumeric1 as alphanumeric, space0 as space},
   combinator::opt,
   multi::many0,
@@ -21,7 +21,7 @@ fn category_and_keys(i: Input<'_>) -> IResult<Input<'_>, (&str, HashMap<&str, &s
 
 fn category(i: Input<'_>) -> IResult<Input<'_>, &str> {
   terminated(
-    delimited('[', take_while(|c| c != ']'), ']'),
+    delimited('[', take_while0(|c| c != ']'), ']'),
     opt(take_while1(" \r\n")),
   )(i)
 }
@@ -33,7 +33,7 @@ fn keys_and_values(input: Input<'_>) -> IResult<Input<'_>, HashMap<&str, &str>>
 fn key_value(i: Input<'_>) -> IResult<Input<'_>, (&str, &str)> {
   let (i, key) = alphanumeric(i)?;
   let (i, _) = (opt(space), "=", opt(space)).parse_next(i)?;
-  let (i, val) = take_till(is_line_ending_or_comment)(i)?;
+  let (i, val) = take_till0(is_line_ending_or_comment)(i)?;
   let (i, _) = opt(space)(i)?;
   let (i, _) = opt((";", not_line_ending))(i)?;
   let (i, _) = opt(space_or_line_ending)(i)?;
@@ -46,7 +46,7 @@ fn is_line_ending_or_comment(chr: char) -> bool {
 }
 
 fn not_line_ending(i: Input<'_>) -> IResult<Input<'_>, &str> {
-  take_while(|c| c != '\r' && c != '\n')(i)
+  take_while0(|c| c != '\r' && c != '\n')(i)
 }
 
 fn space_or_line_ending(i: Input<'_>) -> IResult<Input<'_>, &str> {

examples/json/parser.rs

@@ -4,7 +4,7 @@ use std::str;
 use winnow::prelude::*;
 use winnow::{
   branch::alt,
-  bytes::{any, none_of, tag, take, take_while},
+  bytes::{any, none_of, tag, take, take_while0},
   character::float,
   combinator::cut_err,
   error::{ContextError, ParseError},
@@ -193,9 +193,9 @@ fn key_value<'i, E: ParseError<Input<'i>> + ContextError<Input<'i>, &'static str
 /// first we write parsers for the smallest elements (here a space character),
 /// then we'll combine them in larger parsers
 fn ws<'i, E: ParseError<Input<'i>>>(input: Input<'i>) -> IResult<Input<'i>, &'i str, E> {
-  // nom combinators like `take_while` return a function. That function is the
+  // nom combinators like `take_while0` return a function. That function is the
   // parser,to which we can pass the input
-  take_while(WS)(input)
+  take_while0(WS)(input)
 }
 
 const WS: &str = " \t\r\n";

examples/json/parser_dispatch.rs

@@ -4,7 +4,7 @@ use std::str;
 use winnow::prelude::*;
 use winnow::{
   branch::{alt, dispatch},
-  bytes::{any, none_of, tag, take, take_while},
+  bytes::{any, none_of, tag, take, take_while0},
   character::float,
   combinator::cut_err,
   combinator::fail,
@@ -202,9 +202,9 @@ fn key_value<'i, E: ParseError<Input<'i>> + ContextError<Input<'i>, &'static str
 /// first we write parsers for the smallest elements (here a space character),
 /// then we'll combine them in larger parsers
 fn ws<'i, E: ParseError<Input<'i>>>(input: Input<'i>) -> IResult<Input<'i>, &'i str, E> {
-  // nom combinators like `take_while` return a function. That function is the
+  // nom combinators like `take_while0` return a function. That function is the
   // parser,to which we can pass the input
-  take_while(WS)(input)
+  take_while0(WS)(input)
 }
 
 const WS: &str = " \t\r\n";

examples/json/parser_streaming.rs

@@ -4,7 +4,7 @@ use std::str;
 use winnow::prelude::*;
 use winnow::{
   branch::alt,
-  bytes::{any, none_of, one_of, tag, take, take_while},
+  bytes::{any, none_of, one_of, tag, take, take_while0},
   character::float,
   combinator::{cut_err, rest},
   error::{ContextError, ParseError},
@@ -202,9 +202,9 @@ fn key_value<'i, E: ParseError<Input<'i>> + ContextError<Input<'i>, &'static str
 /// first we write parsers for the smallest elements (here a space character),
 /// then we'll combine them in larger parsers
 fn ws<'i, E: ParseError<Input<'i>>>(input: Input<'i>) -> IResult<Input<'i>, &'i str, E> {
-  // nom combinators like `take_while` return a function. That function is the
+  // nom combinators like `take_while0` return a function. That function is the
   // parser,to which we can pass the input
-  take_while(WS)(input)
+  take_while0(WS)(input)
 }
 
 fn ws_or_eof<'i, E: ParseError<Input<'i>>>(input: Input<'i>) -> IResult<Input<'i>, &'i str, E> {

examples/json_iterator.rs

@@ -4,7 +4,7 @@ use winnow::prelude::*;
 use winnow::{
   branch::alt,
   bytes::one_of,
-  bytes::{tag, take_while},
+  bytes::{tag, take_while0},
   character::{alphanumeric1 as alphanumeric, escaped, float},
   combinator::cut_err,
   error::ParseError,
@@ -206,7 +206,7 @@ impl<'a, 'b: 'a> JsonValue<'a, 'b> {
 fn sp<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &'a str, E> {
   let chars = " \t\r\n";
 
-  take_while(move |c| chars.contains(c))(i)
+  take_while0(move |c| chars.contains(c))(i)
 }
 
 fn parse_str<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &'a str, E> {

src/_cookbook.rs

@@ -84,13 +84,13 @@
 //! use winnow::prelude::*;
 //! use winnow::{
 //!   error::ParseError,
-//!   bytes::{tag, take_until},
+//!   bytes::{tag, take_until0},
 //! };
 //!
 //! pub fn pinline_comment<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, (), E> {
 //!   (
 //!     "(*",
-//!     take_until("*)"),
+//!     take_until0("*)"),
 //!     "*)"
 //!   )
 //!     .void() // Output is thrown away.
@@ -109,14 +109,14 @@
 //! use winnow::prelude::*;
 //! use winnow::{
 //!   input::AsChar,
-//!   bytes::take_while,
+//!   bytes::take_while0,
 //!   bytes::one_of,
 //! };
 //!
 //! pub fn identifier(input: &str) -> IResult<&str, &str> {
 //!   (
 //!       one_of(|c: char| c.is_alpha() || c == '_'),
-//!       take_while(|c: char| c.is_alphanum() || c == '_')
+//!       take_while0(|c: char| c.is_alphanum() || c == '_')
 //!   )
 //!   .recognize()
 //!   .parse_next(input)
@@ -125,7 +125,7 @@
 //!
 //! Let's say we apply this to the identifier `hello_world123abc`. The first element of the tuple
 //! would uses [`one_of`][crate::bytes::one_of] which would recognize `h`. The tuple ensures that
-//! `ello_world123abc` will be piped to the next [`take_while`][crate::bytes::take_while] parser,
+//! `ello_world123abc` will be piped to the next [`take_while0`][crate::bytes::take_while0] parser,
 //! which recognizes every remaining character. However, the tuple returns a tuple of the results
 //! of its sub-parsers. The [`recognize`][crate::Parser::recognize] parser produces a `&str` of the
 //! input text that was parsed, which in this case is the entire `&str` `hello_world123abc`.

src/bytes/complete.rs

@@ -266,8 +266,8 @@ where
 /// assert_eq!(alpha(b""), Ok((&b""[..], &b""[..])));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_while`][crate::bytes::take_while]
-#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_while`")]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_while0`][crate::bytes::take_while0]
+#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_while0`")]
 pub fn take_while<T, I, Error: ParseError<I>>(
   list: T,
 ) -> impl Fn(I) -> IResult<I, <I as Input>::Slice, Error>
@@ -431,8 +431,8 @@ where
 /// assert_eq!(till_colon(""), Ok(("", "")));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_till`][crate::bytes::take_till]
-#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_till`")]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_till0`][crate::bytes::take_till0]
+#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_till0`")]
 #[allow(clippy::redundant_closure)]
 pub fn take_till<T, I, Error: ParseError<I>>(
   list: T,
@@ -577,8 +577,8 @@ where
 /// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_until`][crate::bytes::take_until]
-#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_until`")]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_until0`][crate::bytes::take_until0]
+#[deprecated(since = "0.1.0", note = "Replaced with `winnow::bytes::take_until0`")]
 pub fn take_until<T, I, Error: ParseError<I>>(
   tag: T,
 ) -> impl Fn(I) -> IResult<I, <I as Input>::Slice, Error>

src/bytes/mod.rs

@@ -275,11 +275,11 @@ where
 /// # Example
 /// ```rust
 /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
-/// use winnow::bytes::take_while;
+/// use winnow::bytes::take_while0;
 /// use winnow::input::AsChar;
 ///
 /// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
-///   take_while(AsChar::is_alpha)(s)
+///   take_while0(AsChar::is_alpha)(s)
 /// }
 ///
 /// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
@@ -291,11 +291,11 @@ where
 /// ```rust
 /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
 /// # use winnow::input::Streaming;
-/// use winnow::bytes::take_while;
+/// use winnow::bytes::take_while0;
 /// use winnow::input::AsChar;
 ///
 /// fn alpha(s: Streaming<&[u8]>) -> IResult<Streaming<&[u8]>, &[u8]> {
-///   take_while(AsChar::is_alpha)(s)
+///   take_while0(AsChar::is_alpha)(s)
 /// }
 ///
 /// assert_eq!(alpha(Streaming(b"latin123")), Ok((Streaming(&b"123"[..]), &b"latin"[..])));
@@ -304,7 +304,7 @@ where
 /// assert_eq!(alpha(Streaming(b"")), Err(ErrMode::Incomplete(Needed::new(1))));
 /// ```
 #[inline(always)]
-pub fn take_while<T, I, Error: ParseError<I>, const STREAMING: bool>(
+pub fn take_while0<T, I, Error: ParseError<I>, const STREAMING: bool>(
   list: T,
 ) -> impl Fn(I) -> IResult<I, <I as Input>::Slice, Error>
 where
@@ -462,10 +462,10 @@ where
 /// # Example
 /// ```rust
 /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
-/// use winnow::bytes::take_till;
+/// use winnow::bytes::take_till0;
 ///
 /// fn till_colon(s: &str) -> IResult<&str, &str> {
-///   take_till(|c| c == ':')(s)
+///   take_till0(|c| c == ':')(s)
 /// }
 ///
 /// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
@@ -477,10 +477,10 @@ where
 /// ```rust
 /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
 /// # use winnow::input::Streaming;
-/// use winnow::bytes::take_till;
+/// use winnow::bytes::take_till0;
 ///
 /// fn till_colon(s: Streaming<&str>) -> IResult<Streaming<&str>, &str> {
-///   take_till(|c| c == ':')(s)
+///   take_till0(|c| c == ':')(s)
 /// }
 ///
 /// assert_eq!(till_colon(Streaming("latin:123")), Ok((Streaming(":123"), "latin")));
@@ -489,7 +489,7 @@ where
 /// assert_eq!(till_colon(Streaming("")), Err(ErrMode::Incomplete(Needed::new(1))));
 /// ```
 #[inline(always)]
-pub fn take_till<T, I, Error: ParseError<I>, const STREAMING: bool>(
+pub fn take_till0<T, I, Error: ParseError<I>, const STREAMING: bool>(
   list: T,
 ) -> impl Fn(I) -> IResult<I, <I as Input>::Slice, Error>
 where
@@ -662,10 +662,10 @@ where
 /// # Example
 /// ```rust
 /// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed, IResult};
-/// use winnow::bytes::take_until;
+/// use winnow::bytes::take_until0;
 ///
 /// fn until_eof(s: &str) -> IResult<&str, &str> {
-///   take_until("eof")(s)
+///   take_until0("eof")(s)
 /// }
 ///
 /// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
@@ -677,10 +677,10 @@ where
 /// ```rust
 /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
 /// # use winnow::input::Streaming;
-/// use winnow::bytes::take_until;
+/// use winnow::bytes::take_until0;
 ///
 /// fn until_eof(s: Streaming<&str>) -> IResult<Streaming<&str>, &str> {
-///   take_until("eof")(s)
+///   take_until0("eof")(s)
 /// }
 ///
 /// assert_eq!(until_eof(Streaming("hello, worldeof")), Ok((Streaming("eof"), "hello, world")));
@@ -689,7 +689,7 @@ where
 /// assert_eq!(until_eof(Streaming("1eof2eof")), Ok((Streaming("eof2eof"), "1")));
 /// ```
 #[inline(always)]
-pub fn take_until<T, I, Error: ParseError<I>, const STREAMING: bool>(
+pub fn take_until0<T, I, Error: ParseError<I>, const STREAMING: bool>(
   tag: T,
 ) -> impl Fn(I) -> IResult<I, <I as Input>::Slice, Error>
 where

src/bytes/streaming.rs

@@ -291,10 +291,10 @@ where
 /// assert_eq!(alpha(b""), Err(ErrMode::Incomplete(Needed::new(1))));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_while`][crate::bytes::take_while] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_while0`][crate::bytes::take_while0] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
 #[deprecated(
   since = "0.1.0",
-  note = "Replaced with `winnow::bytes::take_while` with input wrapped in `winnow::input::Streaming`"
+  note = "Replaced with `winnow::bytes::take_while0` with input wrapped in `winnow::input::Streaming`"
 )]
 pub fn take_while<T, I, Error: ParseError<I>>(
   list: T,
@@ -478,10 +478,10 @@ where
 /// assert_eq!(till_colon(""), Err(ErrMode::Incomplete(Needed::new(1))));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_till`][crate::bytes::take_till] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_till0`][crate::bytes::take_till0] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
 #[deprecated(
   since = "0.1.0",
-  note = "Replaced with `winnow::bytes::take_till` with input wrapped in `winnow::input::Streaming`"
+  note = "Replaced with `winnow::bytes::take_till0` with input wrapped in `winnow::input::Streaming`"
 )]
 #[allow(clippy::redundant_closure)]
 pub fn take_till<T, I, Error: ParseError<I>>(
@@ -631,10 +631,10 @@ where
 /// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
 /// ```
 ///
-/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_until`][crate::bytes::take_until] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
+/// **WARNING:** Deprecated, replaced with [`winnow::bytes::take_until0`][crate::bytes::take_until0] with input wrapped in [`winnow::input::Streaming`][crate::input::Streaming]
 #[deprecated(
   since = "0.1.0",
-  note = "Replaced with `winnow::bytes::take_until` with input wrapped in `winnow::input::Streaming`"
+  note = "Replaced with `winnow::bytes::take_until0` with input wrapped in `winnow::input::Streaming`"
 )]
 pub fn take_until<T, I, Error: ParseError<I>>(
   tag: T,