perf(parse)!: Switch from pure parsers to stream mutation

benches/contains_token.rs

@@ -18,19 +18,19 @@ fn contains_token(c: &mut criterion::Criterion) {
         group.throughput(criterion::Throughput::Bytes(len as u64));
 
         group.bench_with_input(criterion::BenchmarkId::new("slice", name), &len, |b, _| {
-            b.iter(|| black_box(parser_slice.parse_next(black_box(sample)).unwrap()));
+            b.iter(|| black_box(parser_slice.parse_peek(black_box(sample)).unwrap()));
         });
         group.bench_with_input(criterion::BenchmarkId::new("array", name), &len, |b, _| {
-            b.iter(|| black_box(parser_array.parse_next(black_box(sample)).unwrap()));
+            b.iter(|| black_box(parser_array.parse_peek(black_box(sample)).unwrap()));
         });
         group.bench_with_input(criterion::BenchmarkId::new("tuple", name), &len, |b, _| {
-            b.iter(|| black_box(parser_tuple.parse_next(black_box(sample)).unwrap()));
+            b.iter(|| black_box(parser_tuple.parse_peek(black_box(sample)).unwrap()));
         });
         group.bench_with_input(
             criterion::BenchmarkId::new("closure-or", name),
             &len,
             |b, _| {
-                b.iter(|| black_box(parser_closure_or.parse_next(black_box(sample)).unwrap()));
+                b.iter(|| black_box(parser_closure_or.parse_peek(black_box(sample)).unwrap()));
             },
         );
         group.bench_with_input(
@@ -40,7 +40,7 @@ fn contains_token(c: &mut criterion::Criterion) {
                 b.iter(|| {
                     black_box(
                         parser_closure_matches
-                            .parse_next(black_box(sample))
+                            .parse_peek(black_box(sample))
                             .unwrap(),
                     )
                 });
@@ -50,22 +50,22 @@ fn contains_token(c: &mut criterion::Criterion) {
     group.finish();
 }
 
-fn parser_slice(input: &str) -> IResult<&str, usize> {
+fn parser_slice(input: &mut &str) -> PResult<usize> {
     let contains = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'][..];
     repeat(0.., alt((take_while(1.., contains), take_till1(contains)))).parse_next(input)
 }
 
-fn parser_array(input: &str) -> IResult<&str, usize> {
+fn parser_array(input: &mut &str) -> PResult<usize> {
     let contains = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
     repeat(0.., alt((take_while(1.., contains), take_till1(contains)))).parse_next(input)
 }
 
-fn parser_tuple(input: &str) -> IResult<&str, usize> {
+fn parser_tuple(input: &mut &str) -> PResult<usize> {
     let contains = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
     repeat(0.., alt((take_while(1.., contains), take_till1(contains)))).parse_next(input)
 }
 
-fn parser_closure_or(input: &str) -> IResult<&str, usize> {
+fn parser_closure_or(input: &mut &str) -> PResult<usize> {
     let contains = |c: char| {
         c == '0'
             || c == '1'
@@ -81,7 +81,7 @@ fn parser_closure_or(input: &str) -> IResult<&str, usize> {
     repeat(0.., alt((take_while(1.., contains), take_till1(contains)))).parse_next(input)
 }
 
-fn parser_closure_matches(input: &str) -> IResult<&str, usize> {
+fn parser_closure_matches(input: &mut &str) -> PResult<usize> {
     let contains = |c: char| matches!(c, '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9');
     repeat(0.., alt((take_while(1.., contains), take_till1(contains)))).parse_next(input)
 }

benches/number.rs

@@ -13,56 +13,55 @@ use winnow::stream::ParseSlice;
 
 type Stream<'i> = &'i [u8];
 
-fn parser(i: Stream<'_>) -> IResult<Stream<'_>, u64> {
-    be_u64(i)
+fn parser(i: &mut Stream<'_>) -> PResult<u64> {
+    be_u64.parse_next(i)
 }
 
 fn number(c: &mut Criterion) {
     let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 
-    parser(&data[..]).expect("should parse correctly");
+    parser
+        .parse_peek(&data[..])
+        .expect("should parse correctly");
     c.bench_function("number", move |b| {
-        b.iter(|| parser(&data[..]).unwrap());
+        b.iter(|| parser.parse_peek(&data[..]).unwrap());
     });
 }
 
 fn float_bytes(c: &mut Criterion) {
     println!(
         "float_bytes result: {:?}",
-        float::<_, f64, Error<_>>(&b"-1.234E-12"[..])
+        float::<_, f64, Error<_>>.parse_peek(&b"-1.234E-12"[..])
     );
     c.bench_function("float bytes", |b| {
-        b.iter(|| float::<_, f64, Error<_>>(&b"-1.234E-12"[..]));
+        b.iter(|| float::<_, f64, Error<_>>.parse_peek(&b"-1.234E-12"[..]));
     });
 }
 
 fn float_str(c: &mut Criterion) {
     println!(
         "float_str result: {:?}",
-        float::<_, f64, Error<_>>("-1.234E-12")
+        float::<_, f64, Error<_>>.parse_peek("-1.234E-12")
     );
     c.bench_function("float str", |b| {
-        b.iter(|| float::<_, f64, Error<_>>("-1.234E-12"));
+        b.iter(|| float::<_, f64, Error<_>>.parse_peek("-1.234E-12"));
     });
 }
 
-fn std_float(input: &[u8]) -> IResult<&[u8], f64, Error<&[u8]>> {
+fn std_float(input: &mut &[u8]) -> PResult<f64> {
     match input.parse_slice() {
-        Some(n) => Ok((&[], n)),
-        None => Err(ErrMode::Backtrack(Error {
-            input,
-            kind: ErrorKind::Slice,
-        })),
+        Some(n) => Ok(n),
+        None => Err(ErrMode::Backtrack(ErrorKind::Slice)),
     }
 }
 
 fn std_float_bytes(c: &mut Criterion) {
     println!(
         "std_float_bytes result: {:?}",
-        std_float(&b"-1.234E-12"[..])
+        std_float.parse_peek(&b"-1.234E-12"[..])
     );
     c.bench_function("std_float bytes", |b| {
-        b.iter(|| std_float(&b"-1.234E-12"[..]));
+        b.iter(|| std_float.parse_peek(&b"-1.234E-12"[..]));
     });
 }
 

examples/arithmetic/bench.rs

@@ -1,17 +1,19 @@
 mod parser;
 
+use winnow::prelude::*;
+
 use parser::expr;
 
 #[allow(clippy::eq_op, clippy::erasing_op)]
 fn arithmetic(c: &mut criterion::Criterion) {
     let data = "  2*2 / ( 5 - 1) + 3 / 4 * (2 - 7 + 567 *12 /2) + 3*(1+2*( 45 /2));";
 
     assert_eq!(
-        expr(data),
+        expr.parse_peek(data),
         Ok((";", 2 * 2 / (5 - 1) + 3 * (1 + 2 * (45 / 2)),))
     );
     c.bench_function("arithmetic", |b| {
-        b.iter(|| expr(data).unwrap());
+        b.iter(|| expr.parse_peek(data).unwrap());
     });
 }
 

examples/arithmetic/parser.rs

@@ -7,13 +7,12 @@ use winnow::{
     combinator::delimited,
     combinator::fold_repeat,
     token::one_of,
-    IResult,
 };
 
 // Parser definition
 
-pub fn expr(i: &str) -> IResult<&str, i64> {
-    let (i, init) = term(i)?;
+pub fn expr(i: &mut &str) -> PResult<i64> {
+    let init = term.parse_next(i)?;
 
     fold_repeat(
         0..,
@@ -33,8 +32,8 @@ pub fn expr(i: &str) -> IResult<&str, i64> {
 // We read an initial factor and for each time we find
 // a * or / operator followed by another factor, we do
 // the math by folding everything
-fn term(i: &str) -> IResult<&str, i64> {
-    let (i, init) = factor(i)?;
+fn term(i: &mut &str) -> PResult<i64> {
+    let init = factor.parse_next(i)?;
 
     fold_repeat(
         0..,
@@ -55,7 +54,7 @@ fn term(i: &str) -> IResult<&str, i64> {
 // We look for a digit suite, and try to convert it.
 // If either str::from_utf8 or FromStr::from_str fail,
 // we fallback to the parens parser defined above
-fn factor(i: &str) -> IResult<&str, i64> {
+fn factor(i: &mut &str) -> PResult<i64> {
     delimited(
         spaces,
         alt((
@@ -69,35 +68,35 @@ fn factor(i: &str) -> IResult<&str, i64> {
 }
 
 // We parse any expr surrounded by parens, ignoring all whitespaces around those
-fn parens(i: &str) -> IResult<&str, i64> {
+fn parens(i: &mut &str) -> PResult<i64> {
     delimited('(', expr, ')').parse_next(i)
 }
 
 #[test]
 fn factor_test() {
-    assert_eq!(factor("3"), Ok(("", 3)));
-    assert_eq!(factor(" 12"), Ok(("", 12)));
-    assert_eq!(factor("537  "), Ok(("", 537)));
-    assert_eq!(factor("  24   "), Ok(("", 24)));
+    assert_eq!(factor.parse_peek("3"), Ok(("", 3)));
+    assert_eq!(factor.parse_peek(" 12"), Ok(("", 12)));
+    assert_eq!(factor.parse_peek("537  "), Ok(("", 537)));
+    assert_eq!(factor.parse_peek("  24   "), Ok(("", 24)));
 }
 
 #[test]
 fn term_test() {
-    assert_eq!(term(" 12 *2 /  3"), Ok(("", 8)));
-    assert_eq!(term(" 2* 3  *2 *2 /  3"), Ok(("", 8)));
-    assert_eq!(term(" 48 /  3/2"), Ok(("", 8)));
+    assert_eq!(term.parse_peek(" 12 *2 /  3"), Ok(("", 8)));
+    assert_eq!(term.parse_peek(" 2* 3  *2 *2 /  3"), Ok(("", 8)));
+    assert_eq!(term.parse_peek(" 48 /  3/2"), Ok(("", 8)));
 }
 
 #[test]
 fn expr_test() {
-    assert_eq!(expr(" 1 +  2 "), Ok(("", 3)));
-    assert_eq!(expr(" 12 + 6 - 4+  3"), Ok(("", 17)));
-    assert_eq!(expr(" 1 + 2*3 + 4"), Ok(("", 11)));
+    assert_eq!(expr.parse_peek(" 1 +  2 "), Ok(("", 3)));
+    assert_eq!(expr.parse_peek(" 12 + 6 - 4+  3"), Ok(("", 17)));
+    assert_eq!(expr.parse_peek(" 1 + 2*3 + 4"), Ok(("", 11)));
 }
 
 #[test]
 fn parens_test() {
-    assert_eq!(expr(" (  2 )"), Ok(("", 2)));
-    assert_eq!(expr(" 2* (  3 + 4 ) "), Ok(("", 14)));
-    assert_eq!(expr("  2*2 / ( 5 - 1) + 3"), Ok(("", 4)));
+    assert_eq!(expr.parse_peek(" (  2 )"), Ok(("", 2)));
+    assert_eq!(expr.parse_peek(" 2* (  3 + 4 ) "), Ok(("", 14)));
+    assert_eq!(expr.parse_peek("  2*2 / ( 5 - 1) + 3"), Ok(("", 4)));
 }

examples/arithmetic/parser_ast.rs

@@ -9,7 +9,6 @@ use winnow::{
     combinator::alt,
     combinator::repeat,
     combinator::{delimited, preceded},
-    IResult,
 };
 
 #[derive(Debug)]
@@ -44,47 +43,47 @@ impl Display for Expr {
     }
 }
 
-pub fn expr(i: &str) -> IResult<&str, Expr> {
-    let (i, initial) = term(i)?;
-    let (i, remainder) = repeat(
+pub fn expr(i: &mut &str) -> PResult<Expr> {
+    let initial = term(i)?;
+    let remainder = repeat(
         0..,
         alt((
-            |i| {
-                let (i, add) = preceded("+", term).parse_next(i)?;
-                Ok((i, (Oper::Add, add)))
+            |i: &mut &str| {
+                let add = preceded("+", term).parse_next(i)?;
+                Ok((Oper::Add, add))
             },
-            |i| {
-                let (i, sub) = preceded("-", term).parse_next(i)?;
-                Ok((i, (Oper::Sub, sub)))
+            |i: &mut &str| {
+                let sub = preceded("-", term).parse_next(i)?;
+                Ok((Oper::Sub, sub))
             },
         )),
     )
     .parse_next(i)?;
 
-    Ok((i, fold_exprs(initial, remainder)))
+    Ok(fold_exprs(initial, remainder))
 }
 
-fn term(i: &str) -> IResult<&str, Expr> {
-    let (i, initial) = factor(i)?;
-    let (i, remainder) = repeat(
+fn term(i: &mut &str) -> PResult<Expr> {
+    let initial = factor(i)?;
+    let remainder = repeat(
         0..,
         alt((
-            |i| {
-                let (i, mul) = preceded("*", factor).parse_next(i)?;
-                Ok((i, (Oper::Mul, mul)))
+            |i: &mut &str| {
+                let mul = preceded("*", factor).parse_next(i)?;
+                Ok((Oper::Mul, mul))
             },
-            |i| {
-                let (i, div) = preceded("/", factor).parse_next(i)?;
-                Ok((i, (Oper::Div, div)))
+            |i: &mut &str| {
+                let div = preceded("/", factor).parse_next(i)?;
+                Ok((Oper::Div, div))
             },
         )),
     )
     .parse_next(i)?;
 
-    Ok((i, fold_exprs(initial, remainder)))
+    Ok(fold_exprs(initial, remainder))
 }
 
-fn factor(i: &str) -> IResult<&str, Expr> {
+fn factor(i: &mut &str) -> PResult<Expr> {
     alt((
         delimited(multispace, digit, multispace)
             .try_map(FromStr::from_str)
@@ -94,7 +93,7 @@ fn factor(i: &str) -> IResult<&str, Expr> {
     .parse_next(i)
 }
 
-fn parens(i: &str) -> IResult<&str, Expr> {
+fn parens(i: &mut &str) -> PResult<Expr> {
     delimited(
         multispace,
         delimited("(", expr.map(|e| Expr::Paren(Box::new(e))), ")"),
@@ -118,42 +117,49 @@ fn fold_exprs(initial: Expr, remainder: Vec<(Oper, Expr)>) -> Expr {
 #[test]
 fn factor_test() {
     assert_eq!(
-        factor("  3  ").map(|(i, x)| (i, format!("{:?}", x))),
+        factor
+            .parse_peek("  3  ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok(("", String::from("Value(3)")))
     );
 }
 
 #[test]
 fn term_test() {
     assert_eq!(
-        term(" 3 *  5   ").map(|(i, x)| (i, format!("{:?}", x))),
+        term.parse_peek(" 3 *  5   ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok(("", String::from("Mul(Value(3), Value(5))")))
     );
 }
 
 #[test]
 fn expr_test() {
     assert_eq!(
-        expr(" 1 + 2 *  3 ").map(|(i, x)| (i, format!("{:?}", x))),
+        expr.parse_peek(" 1 + 2 *  3 ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok(("", String::from("Add(Value(1), Mul(Value(2), Value(3)))")))
     );
     assert_eq!(
-        expr(" 1 + 2 *  3 / 4 - 5 ").map(|(i, x)| (i, format!("{:?}", x))),
+        expr.parse_peek(" 1 + 2 *  3 / 4 - 5 ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok((
             "",
             String::from("Sub(Add(Value(1), Div(Mul(Value(2), Value(3)), Value(4))), Value(5))")
         ))
     );
     assert_eq!(
-        expr(" 72 / 2 / 3 ").map(|(i, x)| (i, format!("{:?}", x))),
+        expr.parse_peek(" 72 / 2 / 3 ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok(("", String::from("Div(Div(Value(72), Value(2)), Value(3))")))
     );
 }
 
 #[test]
 fn parens_test() {
     assert_eq!(
-        expr(" ( 1 + 2 ) *  3 ").map(|(i, x)| (i, format!("{:?}", x))),
+        expr.parse_peek(" ( 1 + 2 ) *  3 ")
+            .map(|(i, x)| (i, format!("{:?}", x))),
         Ok((
             "",
             String::from("Mul(Paren(Add(Value(1), Value(2))), Value(3))")

examples/css/main.rs

@@ -49,7 +49,7 @@ impl Args {
 #[test]
 fn parse_color() {
     assert_eq!(
-        hex_color("#2F14DF"),
+        hex_color.parse_peek("#2F14DF"),
         Ok((
             "",
             parser::Color {