Merging upstream version 1.73.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 359 insertions, 301 deletions

diff --git a/vendor/winnow/src/ascii/tests.rs b/vendor/winnow/src/ascii/tests.rs
index b715d0920..aacbd86f2 100644
--- a/vendor/winnow/src/ascii/tests.rs
+++ b/vendor/winnow/src/ascii/tests.rs
@@ -1,12 +1,13 @@
 use super::*;
+use crate::prelude::*;
 
 mod complete {
     use super::*;
     use crate::combinator::alt;
     use crate::combinator::opt;
     use crate::error::ErrMode;
-    use crate::error::Error;
     use crate::error::ErrorKind;
+    use crate::error::InputError;
     use crate::stream::ParseSlice;
     use crate::token::none_of;
     use crate::token::one_of;
@@ -16,7 +17,7 @@ mod complete {
 
     macro_rules! assert_parse(
     ($left: expr, $right: expr) => {
-      let res: $crate::IResult<_, _, Error<_>> = $left;
+      let res: $crate::IResult<_, _, InputError<_>> = $left;
       assert_eq!(res, $right);
     };
   );
@@ -30,60 +31,75 @@ mod complete {
         let d: &[u8] = "azé12".as_bytes();
         let e: &[u8] = b" ";
         let f: &[u8] = b" ;";
-        //assert_eq!(alpha1::<_, Error>(a), Err(ErrMode::Incomplete(Needed::Size(1))));
-        assert_parse!(alpha1(a), Ok((empty, a)));
+        //assert_eq!(alpha1::<_, InputError>(a), Err(ErrMode::Incomplete(Needed::Size(1))));
+        assert_parse!(alpha1.parse_peek(a), Ok((empty, a)));
         assert_eq!(
-            alpha1(b),
-            Err(ErrMode::Backtrack(Error::new(b, ErrorKind::Slice)))
+            alpha1.parse_peek(b),
+            Err(ErrMode::Backtrack(InputError::new(b, ErrorKind::Slice)))
         );
-        assert_eq!(alpha1::<_, Error<_>>(c), Ok((&c[1..], &b"a"[..])));
-        assert_eq!(alpha1::<_, Error<_>>(d), Ok(("é12".as_bytes(), &b"az"[..])));
         assert_eq!(
-            digit1(a),
-            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+            alpha1::<_, InputError<_>>.parse_peek(c),
+            Ok((&c[1..], &b"a"[..]))
         );
-        assert_eq!(digit1::<_, Error<_>>(b), Ok((empty, b)));
         assert_eq!(
-            digit1(c),
-            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+            alpha1::<_, InputError<_>>.parse_peek(d),
+            Ok(("é12".as_bytes(), &b"az"[..]))
+        );
+        assert_eq!(
+            digit1.parse_peek(a),
+            Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
+        assert_eq!(
+            digit1.parse_peek(c),
+            Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice)))
         );
         assert_eq!(
-            digit1(d),
-            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+            digit1.parse_peek(d),
+            Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice)))
         );
-        assert_eq!(hex_digit1::<_, Error<_>>(a), Ok((empty, a)));
-        assert_eq!(hex_digit1::<_, Error<_>>(b), Ok((empty, b)));
-        assert_eq!(hex_digit1::<_, Error<_>>(c), Ok((empty, c)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(a), Ok((empty, a)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(c), Ok((empty, c)));
         assert_eq!(
-            hex_digit1::<_, Error<_>>(d),
+            hex_digit1::<_, InputError<_>>.parse_peek(d),
             Ok(("zé12".as_bytes(), &b"a"[..]))
         );
         assert_eq!(
-            hex_digit1(e),
-            Err(ErrMode::Backtrack(Error::new(e, ErrorKind::Slice)))
+            hex_digit1.parse_peek(e),
+            Err(ErrMode::Backtrack(InputError::new(e, ErrorKind::Slice)))
         );
         assert_eq!(
-            oct_digit1(a),
-            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+            oct_digit1.parse_peek(a),
+            Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice)))
         );
-        assert_eq!(oct_digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
         assert_eq!(
-            oct_digit1(c),
-            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+            oct_digit1.parse_peek(c),
+            Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice)))
         );
         assert_eq!(
-            oct_digit1(d),
-            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+            oct_digit1.parse_peek(d),
+            Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            alphanumeric1::<_, InputError<_>>.parse_peek(a),
+            Ok((empty, a))
         );
-        assert_eq!(alphanumeric1::<_, Error<_>>(a), Ok((empty, a)));
         //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
-        assert_eq!(alphanumeric1::<_, Error<_>>(c), Ok((empty, c)));
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(d),
+            alphanumeric1::<_, InputError<_>>.parse_peek(c),
+            Ok((empty, c))
+        );
+        assert_eq!(
+            alphanumeric1::<_, InputError<_>>.parse_peek(d),
             Ok(("é12".as_bytes(), &b"az"[..]))
         );
-        assert_eq!(space1::<_, Error<_>>(e), Ok((empty, e)));
-        assert_eq!(space1::<_, Error<_>>(f), Ok((&b";"[..], &b" "[..])));
+        assert_eq!(space1::<_, InputError<_>>.parse_peek(e), Ok((empty, e)));
+        assert_eq!(
+            space1::<_, InputError<_>>.parse_peek(f),
+            Ok((&b";"[..], &b" "[..]))
+        );
     }
 
     #[cfg(feature = "alloc")]
@@ -95,52 +111,64 @@ mod complete {
         let c = "a123";
         let d = "azé12";
         let e = " ";
-        assert_eq!(alpha1::<_, Error<_>>(a), Ok((empty, a)));
+        assert_eq!(alpha1::<_, InputError<_>>.parse_peek(a), Ok((empty, a)));
+        assert_eq!(
+            alpha1.parse_peek(b),
+            Err(ErrMode::Backtrack(InputError::new(b, ErrorKind::Slice)))
+        );
+        assert_eq!(alpha1::<_, InputError<_>>.parse_peek(c), Ok((&c[1..], "a")));
+        assert_eq!(alpha1::<_, InputError<_>>.parse_peek(d), Ok(("é12", "az")));
+        assert_eq!(
+            digit1.parse_peek(a),
+            Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
         assert_eq!(
-            alpha1(b),
-            Err(ErrMode::Backtrack(Error::new(b, ErrorKind::Slice)))
+            digit1.parse_peek(c),
+            Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice)))
         );
-        assert_eq!(alpha1::<_, Error<_>>(c), Ok((&c[1..], "a")));
-        assert_eq!(alpha1::<_, Error<_>>(d), Ok(("é12", "az")));
         assert_eq!(
-            digit1(a),
-            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+            digit1.parse_peek(d),
+            Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice)))
         );
-        assert_eq!(digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(a), Ok((empty, a)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
+        assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(c), Ok((empty, c)));
         assert_eq!(
-            digit1(c),
-            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+            hex_digit1::<_, InputError<_>>.parse_peek(d),
+            Ok(("zé12", "a"))
         );
         assert_eq!(
-            digit1(d),
-            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+            hex_digit1.parse_peek(e),
+            Err(ErrMode::Backtrack(InputError::new(e, ErrorKind::Slice)))
         );
-        assert_eq!(hex_digit1::<_, Error<_>>(a), Ok((empty, a)));
-        assert_eq!(hex_digit1::<_, Error<_>>(b), Ok((empty, b)));
-        assert_eq!(hex_digit1::<_, Error<_>>(c), Ok((empty, c)));
-        assert_eq!(hex_digit1::<_, Error<_>>(d), Ok(("zé12", "a")));
         assert_eq!(
-            hex_digit1(e),
-            Err(ErrMode::Backtrack(Error::new(e, ErrorKind::Slice)))
+            oct_digit1.parse_peek(a),
+            Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice)))
         );
+        assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b)));
         assert_eq!(
-            oct_digit1(a),
-            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+            oct_digit1.parse_peek(c),
+            Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice)))
         );
-        assert_eq!(oct_digit1::<_, Error<_>>(b), Ok((empty, b)));
         assert_eq!(
-            oct_digit1(c),
-            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+            oct_digit1.parse_peek(d),
+            Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice)))
         );
         assert_eq!(
-            oct_digit1(d),
-            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+            alphanumeric1::<_, InputError<_>>.parse_peek(a),
+            Ok((empty, a))
         );
-        assert_eq!(alphanumeric1::<_, Error<_>>(a), Ok((empty, a)));
         //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
-        assert_eq!(alphanumeric1::<_, Error<_>>(c), Ok((empty, c)));
-        assert_eq!(alphanumeric1::<_, Error<_>>(d), Ok(("é12", "az")));
-        assert_eq!(space1::<_, Error<_>>(e), Ok((empty, e)));
+        assert_eq!(
+            alphanumeric1::<_, InputError<_>>.parse_peek(c),
+            Ok((empty, c))
+        );
+        assert_eq!(
+            alphanumeric1::<_, InputError<_>>.parse_peek(d),
+            Ok(("é12", "az"))
+        );
+        assert_eq!(space1::<_, InputError<_>>.parse_peek(e), Ok((empty, e)));
     }
 
     use crate::stream::Offset;
@@ -153,45 +181,45 @@ mod complete {
         let e = &b" \t\r\n;"[..];
         let f = &b"123abcDEF;"[..];
 
-        match alpha1::<_, Error<_>>(a) {
+        match alpha1::<_, InputError<_>>.parse_peek(a) {
             Ok((i, _)) => {
-                assert_eq!(a.offset_to(i) + i.len(), a.len());
+                assert_eq!(i.offset_from(&a) + i.len(), a.len());
             }
             _ => panic!("wrong return type in offset test for alpha"),
         }
-        match digit1::<_, Error<_>>(b) {
+        match digit1::<_, InputError<_>>.parse_peek(b) {
             Ok((i, _)) => {
-                assert_eq!(b.offset_to(i) + i.len(), b.len());
+                assert_eq!(i.offset_from(&b) + i.len(), b.len());
             }
             _ => panic!("wrong return type in offset test for digit"),
         }
-        match alphanumeric1::<_, Error<_>>(c) {
+        match alphanumeric1::<_, InputError<_>>.parse_peek(c) {
             Ok((i, _)) => {
-                assert_eq!(c.offset_to(i) + i.len(), c.len());
+                assert_eq!(i.offset_from(&c) + i.len(), c.len());
             }
             _ => panic!("wrong return type in offset test for alphanumeric"),
         }
-        match space1::<_, Error<_>>(d) {
+        match space1::<_, InputError<_>>.parse_peek(d) {
             Ok((i, _)) => {
-                assert_eq!(d.offset_to(i) + i.len(), d.len());
+                assert_eq!(i.offset_from(&d) + i.len(), d.len());
             }
             _ => panic!("wrong return type in offset test for space"),
         }
-        match multispace1::<_, Error<_>>(e) {
+        match multispace1::<_, InputError<_>>.parse_peek(e) {
             Ok((i, _)) => {
-                assert_eq!(e.offset_to(i) + i.len(), e.len());
+                assert_eq!(i.offset_from(&e) + i.len(), e.len());
             }
             _ => panic!("wrong return type in offset test for multispace"),
         }
-        match hex_digit1::<_, Error<_>>(f) {
+        match hex_digit1::<_, InputError<_>>.parse_peek(f) {
             Ok((i, _)) => {
-                assert_eq!(f.offset_to(i) + i.len(), f.len());
+                assert_eq!(i.offset_from(&f) + i.len(), f.len());
             }
             _ => panic!("wrong return type in offset test for hex_digit"),
         }
-        match oct_digit1::<_, Error<_>>(f) {
+        match oct_digit1::<_, InputError<_>>.parse_peek(f) {
             Ok((i, _)) => {
-                assert_eq!(f.offset_to(i) + i.len(), f.len());
+                assert_eq!(i.offset_from(&f) + i.len(), f.len());
             }
             _ => panic!("wrong return type in offset test for oct_digit"),
         }
@@ -201,53 +229,62 @@ mod complete {
     fn is_not_line_ending_bytes() {
         let a: &[u8] = b"ab12cd\nefgh";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(a),
+            not_line_ending::<_, InputError<_>>.parse_peek(a),
             Ok((&b"\nefgh"[..], &b"ab12cd"[..]))
         );
 
         let b: &[u8] = b"ab12cd\nefgh\nijkl";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(b),
+            not_line_ending::<_, InputError<_>>.parse_peek(b),
             Ok((&b"\nefgh\nijkl"[..], &b"ab12cd"[..]))
         );
 
         let c: &[u8] = b"ab12cd\r\nefgh\nijkl";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(c),
+            not_line_ending::<_, InputError<_>>.parse_peek(c),
             Ok((&b"\r\nefgh\nijkl"[..], &b"ab12cd"[..]))
         );
 
         let d: &[u8] = b"ab12cd";
-        assert_eq!(not_line_ending::<_, Error<_>>(d), Ok((&[][..], d)));
+        assert_eq!(
+            not_line_ending::<_, InputError<_>>.parse_peek(d),
+            Ok((&[][..], d))
+        );
     }
 
     #[test]
     fn is_not_line_ending_str() {
         let f = "βèƒôřè\rÂßÇáƒƭèř";
         assert_eq!(
-            not_line_ending(f),
-            Err(ErrMode::Backtrack(Error::new(f, ErrorKind::Tag)))
+            not_line_ending.parse_peek(f),
+            Err(ErrMode::Backtrack(InputError::new(
+                &f[12..],
+                ErrorKind::Tag
+            )))
         );
 
         let g2: &str = "ab12cd";
-        assert_eq!(not_line_ending::<_, Error<_>>(g2), Ok(("", g2)));
+        assert_eq!(
+            not_line_ending::<_, InputError<_>>.parse_peek(g2),
+            Ok(("", g2))
+        );
     }
 
     #[test]
     fn hex_digit_test() {
         let i = &b"0123456789abcdefABCDEF;"[..];
-        assert_parse!(hex_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
+        assert_parse!(hex_digit1.parse_peek(i), Ok((&b";"[..], &i[..i.len() - 1])));
 
         let i = &b"g"[..];
         assert_parse!(
-            hex_digit1(i),
-            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+            hex_digit1.parse_peek(i),
+            Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice)))
         );
 
         let i = &b"G"[..];
         assert_parse!(
-            hex_digit1(i),
-            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+            hex_digit1.parse_peek(i),
+            Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice)))
         );
 
         assert!(AsChar::is_hex_digit(b'0'));
@@ -267,12 +304,12 @@ mod complete {
     #[test]
     fn oct_digit_test() {
         let i = &b"01234567;"[..];
-        assert_parse!(oct_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
+        assert_parse!(oct_digit1.parse_peek(i), Ok((&b";"[..], &i[..i.len() - 1])));
 
         let i = &b"8"[..];
         assert_parse!(
-            oct_digit1(i),
-            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+            oct_digit1.parse_peek(i),
+            Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice)))
         );
 
         assert!(AsChar::is_oct_digit(b'0'));
@@ -290,7 +327,7 @@ mod complete {
     #[test]
     fn full_line_windows() {
         fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
-            (not_line_ending, line_ending).parse_next(i)
+            (not_line_ending, line_ending).parse_peek(i)
         }
         let input = b"abc\r\n";
         let output = take_full_line(input);
@@ -300,7 +337,7 @@ mod complete {
     #[test]
     fn full_line_unix() {
         fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
-            (not_line_ending, line_ending).parse_next(i)
+            (not_line_ending, line_ending).parse_peek(i)
         }
         let input = b"abc\n";
         let output = take_full_line(input);
@@ -310,87 +347,96 @@ mod complete {
     #[test]
     fn check_windows_lineending() {
         let input = b"\r\n";
-        let output = line_ending(&input[..]);
+        let output = line_ending.parse_peek(&input[..]);
         assert_parse!(output, Ok((&b""[..], &b"\r\n"[..])));
     }
 
     #[test]
     fn check_unix_lineending() {
         let input = b"\n";
-        let output = line_ending(&input[..]);
+        let output = line_ending.parse_peek(&input[..]);
         assert_parse!(output, Ok((&b""[..], &b"\n"[..])));
     }
 
     #[test]
     fn cr_lf() {
-        assert_parse!(crlf(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
         assert_parse!(
-            crlf(&b"\r"[..]),
+            crlf.parse_peek(&b"\r\na"[..]),
+            Ok((&b"a"[..], &b"\r\n"[..]))
+        );
+        assert_parse!(
+            crlf.parse_peek(&b"\r"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b"\r"[..],
+                &&b"\r"[..],
                 ErrorKind::Tag
             )))
         );
         assert_parse!(
-            crlf(&b"\ra"[..]),
+            crlf.parse_peek(&b"\ra"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b"\ra"[..],
+                &&b"\ra"[..],
                 ErrorKind::Tag
             )))
         );
 
-        assert_parse!(crlf("\r\na"), Ok(("a", "\r\n")));
+        assert_parse!(crlf.parse_peek("\r\na"), Ok(("a", "\r\n")));
         assert_parse!(
-            crlf("\r"),
-            Err(ErrMode::Backtrack(error_position!("\r", ErrorKind::Tag)))
+            crlf.parse_peek("\r"),
+            Err(ErrMode::Backtrack(error_position!(&"\r", ErrorKind::Tag)))
         );
         assert_parse!(
-            crlf("\ra"),
-            Err(ErrMode::Backtrack(error_position!("\ra", ErrorKind::Tag)))
+            crlf.parse_peek("\ra"),
+            Err(ErrMode::Backtrack(error_position!(&"\ra", ErrorKind::Tag)))
         );
     }
 
     #[test]
     fn end_of_line() {
-        assert_parse!(line_ending(&b"\na"[..]), Ok((&b"a"[..], &b"\n"[..])));
-        assert_parse!(line_ending(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
         assert_parse!(
-            line_ending(&b"\r"[..]),
+            line_ending.parse_peek(&b"\na"[..]),
+            Ok((&b"a"[..], &b"\n"[..]))
+        );
+        assert_parse!(
+            line_ending.parse_peek(&b"\r\na"[..]),
+            Ok((&b"a"[..], &b"\r\n"[..]))
+        );
+        assert_parse!(
+            line_ending.parse_peek(&b"\r"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b"\r"[..],
+                &&b"\r"[..],
                 ErrorKind::Tag
             )))
         );
         assert_parse!(
-            line_ending(&b"\ra"[..]),
+            line_ending.parse_peek(&b"\ra"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b"\ra"[..],
+                &&b"\ra"[..],
                 ErrorKind::Tag
             )))
         );
 
-        assert_parse!(line_ending("\na"), Ok(("a", "\n")));
-        assert_parse!(line_ending("\r\na"), Ok(("a", "\r\n")));
+        assert_parse!(line_ending.parse_peek("\na"), Ok(("a", "\n")));
+        assert_parse!(line_ending.parse_peek("\r\na"), Ok(("a", "\r\n")));
         assert_parse!(
-            line_ending("\r"),
-            Err(ErrMode::Backtrack(error_position!("\r", ErrorKind::Tag)))
+            line_ending.parse_peek("\r"),
+            Err(ErrMode::Backtrack(error_position!(&"\r", ErrorKind::Tag)))
         );
         assert_parse!(
-            line_ending("\ra"),
-            Err(ErrMode::Backtrack(error_position!("\ra", ErrorKind::Tag)))
+            line_ending.parse_peek("\ra"),
+            Err(ErrMode::Backtrack(error_position!(&"\ra", ErrorKind::Tag)))
         );
     }
 
     fn digit_to_i16(input: &str) -> IResult<&str, i16> {
         let i = input;
-        let (i, opt_sign) = opt(alt(('+', '-'))).parse_next(i)?;
+        let (i, opt_sign) = opt(alt(('+', '-'))).parse_peek(i)?;
         let sign = match opt_sign {
             Some('+') | None => true,
             Some('-') => false,
             _ => unreachable!(),
         };
 
-        let (i, s) = digit1::<_, crate::error::Error<_>>(i)?;
+        let (i, s) = digit1::<_, InputError<_>>.parse_peek(i)?;
         match s.parse_slice() {
             Some(n) => {
                 if sign {
@@ -399,15 +445,15 @@ mod complete {
                     Ok((i, -n))
                 }
             }
-            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+            None => Err(ErrMode::from_error_kind(&i, ErrorKind::Verify)),
         }
     }
 
     fn digit_to_u32(i: &str) -> IResult<&str, u32> {
-        let (i, s) = digit1(i)?;
+        let (i, s) = digit1.parse_peek(i)?;
         match s.parse_slice() {
             Some(n) => Ok((i, n)),
-            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+            None => Err(ErrMode::from_error_kind(&i, ErrorKind::Verify)),
         }
     }
 
@@ -416,7 +462,7 @@ mod complete {
       #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
       fn ints(s in "\\PC*") {
           let res1 = digit_to_i16(&s);
-          let res2 = dec_int(s.as_str());
+          let res2 = dec_int.parse_peek(s.as_str());
           assert_eq!(res1, res2);
       }
 
@@ -424,7 +470,7 @@ mod complete {
       #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
       fn uints(s in "\\PC*") {
           let res1 = digit_to_u32(&s);
-          let res2 = dec_uint(s.as_str());
+          let res2 = dec_uint.parse_peek(s.as_str());
           assert_eq!(res1, res2);
       }
     }
@@ -432,13 +478,13 @@ mod complete {
     #[test]
     fn hex_uint_tests() {
         fn hex_u32(input: &[u8]) -> IResult<&[u8], u32> {
-            hex_uint(input)
+            hex_uint.parse_peek(input)
         }
 
         assert_parse!(
             hex_u32(&b";"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b";"[..],
+                &&b";"[..],
                 ErrorKind::Slice
             )))
         );
@@ -449,14 +495,14 @@ mod complete {
         assert_parse!(
             hex_u32(&b"00c5a31be2;"[..]), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                &b"00c5a31be2;"[..],
+                &&b"00c5a31be2;"[..],
                 ErrorKind::Verify
             )))
         );
         assert_parse!(
             hex_u32(&b"c5a31be201;"[..]), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                &b"c5a31be201;"[..],
+                &&b"c5a31be201;"[..],
                 ErrorKind::Verify
             )))
         );
@@ -464,14 +510,14 @@ mod complete {
         assert_parse!(
             hex_u32(&b"ffffffffffffffff;"[..]), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                &b"ffffffffffffffff;"[..],
+                &&b"ffffffffffffffff;"[..],
                 ErrorKind::Verify
             )))
         );
         assert_parse!(
             hex_u32(&b"ffffffffffffffff"[..]), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                &b"ffffffffffffffff"[..],
+                &&b"ffffffffffffffff"[..],
                 ErrorKind::Verify
             )))
         );
@@ -510,35 +556,40 @@ mod complete {
 
             let larger = test.to_string();
 
-            assert_parse!(float(larger.as_bytes()), Ok((&b""[..], expected32)));
-            assert_parse!(float(&larger[..]), Ok(("", expected32)));
-
-            assert_parse!(float(larger.as_bytes()), Ok((&b""[..], expected64)));
-            assert_parse!(float(&larger[..]), Ok(("", expected64)));
+            assert_parse!(
+                float.parse_peek(larger.as_bytes()),
+                Ok((&b""[..], expected32))
+            );
+            assert_parse!(float.parse_peek(&larger[..]), Ok(("", expected32)));
+
+            assert_parse!(
+                float.parse_peek(larger.as_bytes()),
+                Ok((&b""[..], expected64))
+            );
+            assert_parse!(float.parse_peek(&larger[..]), Ok(("", expected64)));
         }
 
         let remaining_exponent = "-1.234E-";
         assert_parse!(
-            float::<_, f64, _>(remaining_exponent),
-            Err(ErrMode::Cut(Error {
-                input: "",
-                kind: ErrorKind::Slice
-            }))
+            float::<_, f64, _>.parse_peek(remaining_exponent),
+            Err(ErrMode::Cut(InputError::new("", ErrorKind::Slice)))
         );
 
-        let (_i, nan) = float::<_, f32, ()>("NaN").unwrap();
+        let (i, nan) = float::<_, f32, ()>.parse_peek("NaN").unwrap();
         assert!(nan.is_nan());
+        assert_eq!(i, "");
 
-        let (_i, inf) = float::<_, f32, ()>("inf").unwrap();
+        let (i, inf) = float::<_, f32, ()>.parse_peek("inf").unwrap();
         assert!(inf.is_infinite());
-        let (_i, inf) = float::<_, f32, ()>("infinite").unwrap();
+        assert_eq!(i, "");
+        let (i, inf) = float::<_, f32, ()>.parse_peek("infinity").unwrap();
         assert!(inf.is_infinite());
+        assert_eq!(i, "");
     }
 
     #[cfg(feature = "std")]
     fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
-        #[allow(deprecated)] // will just become `pub(crate)` later
-        match super::recognize_float_or_exceptions(i) {
+        match super::recognize_float_or_exceptions.parse_peek(i) {
             Err(e) => Err(e),
             Ok((i, s)) => {
                 if s.is_empty() {
@@ -559,7 +610,7 @@ mod complete {
       fn floats(s in "\\PC*") {
           println!("testing {}", s);
           let res1 = parse_f64(&s);
-          let res2 = float::<_, f64, ()>(s.as_str());
+          let res2 = float::<_, f64, ()>.parse_peek(s.as_str());
           assert_eq!(res1, res2);
       }
     }
@@ -571,7 +622,7 @@ mod complete {
         fn escaped_string(input: &str) -> IResult<&str, &str> {
             use crate::ascii::alpha0;
             use crate::token::one_of;
-            escaped(alpha0, '\\', one_of("n")).parse_next(input)
+            escaped(alpha0, '\\', one_of(['n'])).parse_peek(input)
         }
 
         escaped_string("7").unwrap();
@@ -588,10 +639,14 @@ mod complete {
 
             delimited(
                 '"',
-                escaped(opt(none_of(r#"\""#)), '\\', one_of(r#"\"rnt"#)),
+                escaped(
+                    opt(none_of(['\\', '"'])),
+                    '\\',
+                    one_of(['\\', '"', 'r', 'n', 't']),
+                ),
                 '"',
             )
-            .parse_next(input)
+            .parse_peek(input)
         }
 
         assert_eq!(unquote(r#""""#), Ok(("", "")));
@@ -605,7 +660,7 @@ mod complete {
         use crate::token::one_of;
 
         fn esc(i: &[u8]) -> IResult<&[u8], &[u8]> {
-            escaped(alpha, '\\', one_of("\"n\\")).parse_next(i)
+            escaped(alpha, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i)
         }
         assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], &b"abcd"[..])));
         assert_eq!(esc(&b"ab\\\"cd;"[..]), Ok((&b";"[..], &b"ab\\\"cd"[..])));
@@ -615,21 +670,21 @@ mod complete {
         assert_eq!(
             esc(&b"AB\\"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b""[..],
+                &&b""[..],
                 ErrorKind::Token
             )))
         );
         assert_eq!(
             esc(&b"AB\\A"[..]),
             Err(ErrMode::Backtrack(error_node_position!(
-                &b"AB\\A"[..],
+                &&b"AB\\A"[..],
                 ErrorKind::Token,
-                error_position!(&b"A"[..], ErrorKind::Verify)
+                error_position!(&&b"A"[..], ErrorKind::Verify)
             )))
         );
 
         fn esc2(i: &[u8]) -> IResult<&[u8], &[u8]> {
-            escaped(digit, '\\', one_of("\"n\\")).parse_next(i)
+            escaped(digit, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i)
         }
         assert_eq!(esc2(&b"12\\nnn34"[..]), Ok((&b"nn34"[..], &b"12\\n"[..])));
     }
@@ -641,7 +696,7 @@ mod complete {
         use crate::token::one_of;
 
         fn esc(i: &str) -> IResult<&str, &str> {
-            escaped(alpha, '\\', one_of("\"n\\")).parse_next(i)
+            escaped(alpha, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i)
         }
         assert_eq!(esc("abcd;"), Ok((";", "abcd")));
         assert_eq!(esc("ab\\\"cd;"), Ok((";", "ab\\\"cd")));
@@ -650,24 +705,24 @@ mod complete {
         assert_eq!(esc("ab\\\"12"), Ok(("12", "ab\\\"")));
         assert_eq!(
             esc("AB\\"),
-            Err(ErrMode::Backtrack(error_position!("", ErrorKind::Token)))
+            Err(ErrMode::Backtrack(error_position!(&"", ErrorKind::Token)))
         );
         assert_eq!(
             esc("AB\\A"),
             Err(ErrMode::Backtrack(error_node_position!(
-                "AB\\A",
+                &"AB\\A",
                 ErrorKind::Token,
-                error_position!("A", ErrorKind::Verify)
+                error_position!(&"A", ErrorKind::Verify)
             )))
         );
 
         fn esc2(i: &str) -> IResult<&str, &str> {
-            escaped(digit, '\\', one_of("\"n\\")).parse_next(i)
+            escaped(digit, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i)
         }
         assert_eq!(esc2("12\\nnn34"), Ok(("nn34", "12\\n")));
 
         fn esc3(i: &str) -> IResult<&str, &str> {
-            escaped(alpha, '\u{241b}', one_of("\"n")).parse_next(i)
+            escaped(alpha, '\u{241b}', one_of(['\"', 'n'])).parse_peek(i)
         }
         assert_eq!(esc3("ab␛ncd;"), Ok((";", "ab␛ncd")));
     }
@@ -676,7 +731,7 @@ mod complete {
     fn test_escaped_error() {
         fn esc(s: &str) -> IResult<&str, &str> {
             use crate::ascii::digit1;
-            escaped(digit1, '\\', one_of("\"n\\")).parse_next(s)
+            escaped(digit1, '\\', one_of(['\"', 'n', '\\'])).parse_peek(s)
         }
 
         assert_eq!(esc("abcd"), Ok(("abcd", "")));
@@ -703,7 +758,7 @@ mod complete {
                 )),
             )
             .map(to_s)
-            .parse_next(i)
+            .parse_peek(i)
         }
 
         assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], String::from("abcd"))));
@@ -723,16 +778,16 @@ mod complete {
         assert_eq!(
             esc(&b"AB\\"[..]),
             Err(ErrMode::Backtrack(error_position!(
-                &b""[..],
+                &&b""[..],
                 ErrorKind::Tag
             )))
         );
         assert_eq!(
             esc(&b"AB\\A"[..]),
             Err(ErrMode::Backtrack(error_node_position!(
-                &b"AB\\A"[..],
+                &&b"AB\\A"[..],
                 ErrorKind::Eof,
-                error_position!(&b"A"[..], ErrorKind::Tag)
+                error_position!(&&b"A"[..], ErrorKind::Tag)
             )))
         );
 
@@ -746,7 +801,7 @@ mod complete {
                 )),
             )
             .map(to_s)
-            .parse_next(i)
+            .parse_peek(i)
         }
         assert_eq!(
             esc2(&b"ab&egrave;DEF;"[..]),
@@ -769,7 +824,7 @@ mod complete {
                 '\\',
                 alt(("\\".value("\\"), "\"".value("\""), "n".value("\n"))),
             )
-            .parse_next(i)
+            .parse_peek(i)
         }
 
         assert_eq!(esc("abcd;"), Ok((";", String::from("abcd"))));
@@ -779,14 +834,14 @@ mod complete {
         assert_eq!(esc("ab\\\"12"), Ok(("12", String::from("ab\""))));
         assert_eq!(
             esc("AB\\"),
-            Err(ErrMode::Backtrack(error_position!("", ErrorKind::Tag)))
+            Err(ErrMode::Backtrack(error_position!(&"", ErrorKind::Tag)))
         );
         assert_eq!(
             esc("AB\\A"),
             Err(ErrMode::Backtrack(error_node_position!(
-                "AB\\A",
+                &"AB\\A",
                 ErrorKind::Eof,
-                error_position!("A", ErrorKind::Tag)
+                error_position!(&"A", ErrorKind::Tag)
             )))
         );
 
@@ -796,7 +851,7 @@ mod complete {
                 '&',
                 alt(("egrave;".value("è"), "agrave;".value("à"))),
             )
-            .parse_next(i)
+            .parse_peek(i)
         }
         assert_eq!(esc2("ab&egrave;DEF;"), Ok((";", String::from("abèDEF"))));
         assert_eq!(
@@ -805,7 +860,7 @@ mod complete {
         );
 
         fn esc3(i: &str) -> IResult<&str, String> {
-            escaped_transform(alpha, '␛', alt(("0".value("\0"), "n".value("\n")))).parse_next(i)
+            escaped_transform(alpha, '␛', alt(("0".value("\0"), "n".value("\n")))).parse_peek(i)
         }
         assert_eq!(esc3("a␛0bc␛n"), Ok(("", String::from("a\0bc\n"))));
     }
@@ -815,7 +870,7 @@ mod complete {
     fn test_escaped_transform_error() {
         fn esc_trans(s: &str) -> IResult<&str, String> {
             use crate::ascii::digit1;
-            escaped_transform(digit1, '\\', "n").parse_next(s)
+            escaped_transform(digit1, '\\', "n").parse_peek(s)
         }
 
         assert_eq!(esc_trans("abcd"), Ok(("abcd", String::new())));
@@ -825,8 +880,8 @@ mod complete {
 mod partial {
     use super::*;
     use crate::combinator::opt;
-    use crate::error::Error;
     use crate::error::ErrorKind;
+    use crate::error::InputError;
     use crate::error::{ErrMode, Needed};
     use crate::stream::ParseSlice;
     use crate::IResult;
@@ -835,7 +890,7 @@ mod partial {
 
     macro_rules! assert_parse(
     ($left: expr, $right: expr) => {
-      let res: $crate::IResult<_, _, Error<_>> = $left;
+      let res: $crate::IResult<_, _, InputError<_>> = $left;
       assert_eq!(res, $right);
     };
   );
@@ -850,116 +905,116 @@ mod partial {
         let f: &[u8] = b" ;";
         //assert_eq!(alpha1::<_, Error<_>>(a), Err(ErrMode::Incomplete(Needed::new(1))));
         assert_parse!(
-            alpha1(Partial::new(a)),
+            alpha1.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            alpha1(Partial::new(b)),
-            Err(ErrMode::Backtrack(Error::new(
+            alpha1.parse_peek(Partial::new(b)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(b),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            alpha1::<_, Error<_>>(Partial::new(c)),
+            alpha1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Ok((Partial::new(&c[1..]), &b"a"[..]))
         );
         assert_eq!(
-            alpha1::<_, Error<_>>(Partial::new(d)),
+            alpha1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("é12".as_bytes()), &b"az"[..]))
         );
         assert_eq!(
-            digit1(Partial::new(a)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(a)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(a),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            digit1::<_, Error<_>>(Partial::new(b)),
+            digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            digit1(Partial::new(c)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(c)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(c),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            digit1(Partial::new(d)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(d)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(d),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(a)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(b)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(c)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(d)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("zé12".as_bytes()), &b"a"[..]))
         );
         assert_eq!(
-            hex_digit1(Partial::new(e)),
-            Err(ErrMode::Backtrack(Error::new(
+            hex_digit1.parse_peek(Partial::new(e)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(e),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1(Partial::new(a)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(a)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(a),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1::<_, Error<_>>(Partial::new(b)),
+            oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            oct_digit1(Partial::new(c)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(c)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(c),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1(Partial::new(d)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(d)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(d),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(a)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(c)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(d)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("é12".as_bytes()), &b"az"[..]))
         );
         assert_eq!(
-            space1::<_, Error<_>>(Partial::new(e)),
+            space1::<_, InputError<_>>.parse_peek(Partial::new(e)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            space1::<_, Error<_>>(Partial::new(f)),
+            space1::<_, InputError<_>>.parse_peek(Partial::new(f)),
             Ok((Partial::new(&b";"[..]), &b" "[..]))
         );
     }
@@ -973,112 +1028,112 @@ mod partial {
         let d = "azé12";
         let e = " ";
         assert_eq!(
-            alpha1::<_, Error<_>>(Partial::new(a)),
+            alpha1::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            alpha1(Partial::new(b)),
-            Err(ErrMode::Backtrack(Error::new(
+            alpha1.parse_peek(Partial::new(b)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(b),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            alpha1::<_, Error<_>>(Partial::new(c)),
+            alpha1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Ok((Partial::new(&c[1..]), "a"))
         );
         assert_eq!(
-            alpha1::<_, Error<_>>(Partial::new(d)),
+            alpha1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("é12"), "az"))
         );
         assert_eq!(
-            digit1(Partial::new(a)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(a)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(a),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            digit1::<_, Error<_>>(Partial::new(b)),
+            digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            digit1(Partial::new(c)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(c)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(c),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            digit1(Partial::new(d)),
-            Err(ErrMode::Backtrack(Error::new(
+            digit1.parse_peek(Partial::new(d)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(d),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(a)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(b)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(c)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            hex_digit1::<_, Error<_>>(Partial::new(d)),
+            hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("zé12"), "a"))
         );
         assert_eq!(
-            hex_digit1(Partial::new(e)),
-            Err(ErrMode::Backtrack(Error::new(
+            hex_digit1.parse_peek(Partial::new(e)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(e),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1(Partial::new(a)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(a)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(a),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1::<_, Error<_>>(Partial::new(b)),
+            oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            oct_digit1(Partial::new(c)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(c)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(c),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            oct_digit1(Partial::new(d)),
-            Err(ErrMode::Backtrack(Error::new(
+            oct_digit1.parse_peek(Partial::new(d)),
+            Err(ErrMode::Backtrack(InputError::new(
                 Partial::new(d),
                 ErrorKind::Slice
             )))
         );
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(a)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(c)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_eq!(
-            alphanumeric1::<_, Error<_>>(Partial::new(d)),
+            alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(d)),
             Ok((Partial::new("é12"), "az"))
         );
         assert_eq!(
-            space1::<_, Error<_>>(Partial::new(e)),
+            space1::<_, InputError<_>>.parse_peek(Partial::new(e)),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
     }
@@ -1093,52 +1148,52 @@ mod partial {
         let e = &b" \t\r\n;"[..];
         let f = &b"123abcDEF;"[..];
 
-        match alpha1::<_, Error<_>>(Partial::new(a)) {
+        match alpha1::<_, InputError<_>>.parse_peek(Partial::new(a)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(a.offset_to(i) + i.len(), a.len());
+                assert_eq!(i.offset_from(&a) + i.len(), a.len());
             }
             _ => panic!("wrong return type in offset test for alpha"),
         }
-        match digit1::<_, Error<_>>(Partial::new(b)) {
+        match digit1::<_, InputError<_>>.parse_peek(Partial::new(b)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(b.offset_to(i) + i.len(), b.len());
+                assert_eq!(i.offset_from(&b) + i.len(), b.len());
             }
             _ => panic!("wrong return type in offset test for digit"),
         }
-        match alphanumeric1::<_, Error<_>>(Partial::new(c)) {
+        match alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(c.offset_to(i) + i.len(), c.len());
+                assert_eq!(i.offset_from(&c) + i.len(), c.len());
             }
             _ => panic!("wrong return type in offset test for alphanumeric"),
         }
-        match space1::<_, Error<_>>(Partial::new(d)) {
+        match space1::<_, InputError<_>>.parse_peek(Partial::new(d)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(d.offset_to(i) + i.len(), d.len());
+                assert_eq!(i.offset_from(&d) + i.len(), d.len());
             }
             _ => panic!("wrong return type in offset test for space"),
         }
-        match multispace1::<_, Error<_>>(Partial::new(e)) {
+        match multispace1::<_, InputError<_>>.parse_peek(Partial::new(e)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(e.offset_to(i) + i.len(), e.len());
+                assert_eq!(i.offset_from(&e) + i.len(), e.len());
             }
             _ => panic!("wrong return type in offset test for multispace"),
         }
-        match hex_digit1::<_, Error<_>>(Partial::new(f)) {
+        match hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(f)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(f.offset_to(i) + i.len(), f.len());
+                assert_eq!(i.offset_from(&f) + i.len(), f.len());
             }
             _ => panic!("wrong return type in offset test for hex_digit"),
         }
-        match oct_digit1::<_, Error<_>>(Partial::new(f)) {
+        match oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(f)) {
             Ok((i, _)) => {
                 let i = i.into_inner();
-                assert_eq!(f.offset_to(i) + i.len(), f.len());
+                assert_eq!(i.offset_from(&f) + i.len(), f.len());
             }
             _ => panic!("wrong return type in offset test for oct_digit"),
         }
@@ -1148,26 +1203,26 @@ mod partial {
     fn is_not_line_ending_bytes() {
         let a: &[u8] = b"ab12cd\nefgh";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(Partial::new(a)),
+            not_line_ending::<_, InputError<_>>.parse_peek(Partial::new(a)),
             Ok((Partial::new(&b"\nefgh"[..]), &b"ab12cd"[..]))
         );
 
         let b: &[u8] = b"ab12cd\nefgh\nijkl";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(Partial::new(b)),
+            not_line_ending::<_, InputError<_>>.parse_peek(Partial::new(b)),
             Ok((Partial::new(&b"\nefgh\nijkl"[..]), &b"ab12cd"[..]))
         );
 
         let c: &[u8] = b"ab12cd\r\nefgh\nijkl";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(Partial::new(c)),
+            not_line_ending::<_, InputError<_>>.parse_peek(Partial::new(c)),
             Ok((Partial::new(&b"\r\nefgh\nijkl"[..]), &b"ab12cd"[..]))
         );
 
         let d: &[u8] = b"ab12cd";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(Partial::new(d)),
-            Err(ErrMode::Incomplete(Needed::Unknown))
+            not_line_ending::<_, InputError<_>>.parse_peek(Partial::new(d)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
         );
     }
 
@@ -1175,17 +1230,17 @@ mod partial {
     fn is_not_line_ending_str() {
         let f = "βèƒôřè\rÂßÇáƒƭèř";
         assert_eq!(
-            not_line_ending(Partial::new(f)),
-            Err(ErrMode::Backtrack(Error::new(
-                Partial::new(f),
+            not_line_ending.parse_peek(Partial::new(f)),
+            Err(ErrMode::Backtrack(InputError::new(
+                Partial::new(&f[12..]),
                 ErrorKind::Tag
             )))
         );
 
         let g2: &str = "ab12cd";
         assert_eq!(
-            not_line_ending::<_, Error<_>>(Partial::new(g2)),
-            Err(ErrMode::Incomplete(Needed::Unknown))
+            not_line_ending::<_, InputError<_>>.parse_peek(Partial::new(g2)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
         );
     }
 
@@ -1193,24 +1248,24 @@ mod partial {
     fn hex_digit_test() {
         let i = &b"0123456789abcdefABCDEF;"[..];
         assert_parse!(
-            hex_digit1(Partial::new(i)),
+            hex_digit1.parse_peek(Partial::new(i)),
             Ok((Partial::new(&b";"[..]), &i[..i.len() - 1]))
         );
 
         let i = &b"g"[..];
         assert_parse!(
-            hex_digit1(Partial::new(i)),
+            hex_digit1.parse_peek(Partial::new(i)),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(i),
+                &Partial::new(i),
                 ErrorKind::Slice
             )))
         );
 
         let i = &b"G"[..];
         assert_parse!(
-            hex_digit1(Partial::new(i)),
+            hex_digit1.parse_peek(Partial::new(i)),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(i),
+                &Partial::new(i),
                 ErrorKind::Slice
             )))
         );
@@ -1233,15 +1288,15 @@ mod partial {
     fn oct_digit_test() {
         let i = &b"01234567;"[..];
         assert_parse!(
-            oct_digit1(Partial::new(i)),
+            oct_digit1.parse_peek(Partial::new(i)),
             Ok((Partial::new(&b";"[..]), &i[..i.len() - 1]))
         );
 
         let i = &b"8"[..];
         assert_parse!(
-            oct_digit1(Partial::new(i)),
+            oct_digit1.parse_peek(Partial::new(i)),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(i),
+                &Partial::new(i),
                 ErrorKind::Slice
             )))
         );
@@ -1262,7 +1317,7 @@ mod partial {
     fn full_line_windows() {
         #[allow(clippy::type_complexity)]
         fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
-            (not_line_ending, line_ending).parse_next(i)
+            (not_line_ending, line_ending).parse_peek(i)
         }
         let input = b"abc\r\n";
         let output = take_full_line(Partial::new(input));
@@ -1276,7 +1331,7 @@ mod partial {
     fn full_line_unix() {
         #[allow(clippy::type_complexity)]
         fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
-            (not_line_ending, line_ending).parse_next(i)
+            (not_line_ending, line_ending).parse_peek(i)
         }
         let input = b"abc\n";
         let output = take_full_line(Partial::new(input));
@@ -1289,44 +1344,47 @@ mod partial {
     #[test]
     fn check_windows_lineending() {
         let input = b"\r\n";
-        let output = line_ending(Partial::new(&input[..]));
+        let output = line_ending.parse_peek(Partial::new(&input[..]));
         assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\r\n"[..])));
     }
 
     #[test]
     fn check_unix_lineending() {
         let input = b"\n";
-        let output = line_ending(Partial::new(&input[..]));
+        let output = line_ending.parse_peek(Partial::new(&input[..]));
         assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\n"[..])));
     }
 
     #[test]
     fn cr_lf() {
         assert_parse!(
-            crlf(Partial::new(&b"\r\na"[..])),
+            crlf.parse_peek(Partial::new(&b"\r\na"[..])),
             Ok((Partial::new(&b"a"[..]), &b"\r\n"[..]))
         );
         assert_parse!(
-            crlf(Partial::new(&b"\r"[..])),
+            crlf.parse_peek(Partial::new(&b"\r"[..])),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_parse!(
-            crlf(Partial::new(&b"\ra"[..])),
+            crlf.parse_peek(Partial::new(&b"\ra"[..])),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"\ra"[..]),
+                &Partial::new(&b"\ra"[..]),
                 ErrorKind::Tag
             )))
         );
 
-        assert_parse!(crlf(Partial::new("\r\na")), Ok((Partial::new("a"), "\r\n")));
         assert_parse!(
-            crlf(Partial::new("\r")),
+            crlf.parse_peek(Partial::new("\r\na")),
+            Ok((Partial::new("a"), "\r\n"))
+        );
+        assert_parse!(
+            crlf.parse_peek(Partial::new("\r")),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_parse!(
-            crlf(Partial::new("\ra")),
+            crlf.parse_peek(Partial::new("\ra")),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new("\ra"),
+                &Partial::new("\ra"),
                 ErrorKind::Tag
             )))
         );
@@ -1335,41 +1393,41 @@ mod partial {
     #[test]
     fn end_of_line() {
         assert_parse!(
-            line_ending(Partial::new(&b"\na"[..])),
+            line_ending.parse_peek(Partial::new(&b"\na"[..])),
             Ok((Partial::new(&b"a"[..]), &b"\n"[..]))
         );
         assert_parse!(
-            line_ending(Partial::new(&b"\r\na"[..])),
+            line_ending.parse_peek(Partial::new(&b"\r\na"[..])),
             Ok((Partial::new(&b"a"[..]), &b"\r\n"[..]))
         );
         assert_parse!(
-            line_ending(Partial::new(&b"\r"[..])),
+            line_ending.parse_peek(Partial::new(&b"\r"[..])),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_parse!(
-            line_ending(Partial::new(&b"\ra"[..])),
+            line_ending.parse_peek(Partial::new(&b"\ra"[..])),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"\ra"[..]),
+                &Partial::new(&b"\ra"[..]),
                 ErrorKind::Tag
             )))
         );
 
         assert_parse!(
-            line_ending(Partial::new("\na")),
+            line_ending.parse_peek(Partial::new("\na")),
             Ok((Partial::new("a"), "\n"))
         );
         assert_parse!(
-            line_ending(Partial::new("\r\na")),
+            line_ending.parse_peek(Partial::new("\r\na")),
             Ok((Partial::new("a"), "\r\n"))
         );
         assert_parse!(
-            line_ending(Partial::new("\r")),
+            line_ending.parse_peek(Partial::new("\r")),
             Err(ErrMode::Incomplete(Needed::new(1)))
         );
         assert_parse!(
-            line_ending(Partial::new("\ra")),
+            line_ending.parse_peek(Partial::new("\ra")),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new("\ra"),
+                &Partial::new("\ra"),
                 ErrorKind::Tag
             )))
         );
@@ -1377,14 +1435,14 @@ mod partial {
 
     fn digit_to_i16(input: Partial<&str>) -> IResult<Partial<&str>, i16> {
         let i = input;
-        let (i, opt_sign) = opt(one_of("+-")).parse_next(i)?;
+        let (i, opt_sign) = opt(one_of(['+', '-'])).parse_peek(i)?;
         let sign = match opt_sign {
             Some('+') | None => true,
             Some('-') => false,
             _ => unreachable!(),
         };
 
-        let (i, s) = digit1::<_, crate::error::Error<_>>(i)?;
+        let (i, s) = digit1::<_, InputError<_>>.parse_peek(i)?;
         match s.parse_slice() {
             Some(n) => {
                 if sign {
@@ -1393,15 +1451,15 @@ mod partial {
                     Ok((i, -n))
                 }
             }
-            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+            None => Err(ErrMode::from_error_kind(&i, ErrorKind::Verify)),
         }
     }
 
     fn digit_to_u32(i: Partial<&str>) -> IResult<Partial<&str>, u32> {
-        let (i, s) = digit1(i)?;
+        let (i, s) = digit1.parse_peek(i)?;
         match s.parse_slice() {
             Some(n) => Ok((i, n)),
-            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+            None => Err(ErrMode::from_error_kind(&i, ErrorKind::Verify)),
         }
     }
 
@@ -1410,7 +1468,7 @@ mod partial {
       #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
       fn ints(s in "\\PC*") {
           let res1 = digit_to_i16(Partial::new(&s));
-          let res2 = dec_int(Partial::new(s.as_str()));
+          let res2 = dec_int.parse_peek(Partial::new(s.as_str()));
           assert_eq!(res1, res2);
       }
 
@@ -1418,7 +1476,7 @@ mod partial {
       #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
       fn uints(s in "\\PC*") {
           let res1 = digit_to_u32(Partial::new(&s));
-          let res2 = dec_uint(Partial::new(s.as_str()));
+          let res2 = dec_uint.parse_peek(Partial::new(s.as_str()));
           assert_eq!(res1, res2);
       }
     }
@@ -1426,13 +1484,13 @@ mod partial {
     #[test]
     fn hex_uint_tests() {
         fn hex_u32(input: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
-            hex_uint(input)
+            hex_uint.parse_peek(input)
         }
 
         assert_parse!(
             hex_u32(Partial::new(&b";"[..])),
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b";"[..]),
+                &Partial::new(&b";"[..]),
                 ErrorKind::Slice
             )))
         );
@@ -1455,14 +1513,14 @@ mod partial {
         assert_parse!(
             hex_u32(Partial::new(&b"00c5a31be2;"[..])), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"00c5a31be2;"[..]),
+                &Partial::new(&b"00c5a31be2;"[..]),
                 ErrorKind::Verify
             )))
         );
         assert_parse!(
             hex_u32(Partial::new(&b"c5a31be201;"[..])), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"c5a31be201;"[..]),
+                &Partial::new(&b"c5a31be201;"[..]),
                 ErrorKind::Verify
             )))
         );
@@ -1473,14 +1531,14 @@ mod partial {
         assert_parse!(
             hex_u32(Partial::new(&b"ffffffffffffffff;"[..])), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"ffffffffffffffff;"[..]),
+                &Partial::new(&b"ffffffffffffffff;"[..]),
                 ErrorKind::Verify
             )))
         );
         assert_parse!(
             hex_u32(Partial::new(&b"ffffffffffffffff"[..])), // overflow
             Err(ErrMode::Backtrack(error_position!(
-                Partial::new(&b"ffffffffffffffff"[..]),
+                &Partial::new(&b"ffffffffffffffff"[..]),
                 ErrorKind::Verify
             )))
         );