Vendor things

third-party/vendor/winnow/examples/iterator.rs

@@ -0,0 +1,77 @@
+use std::collections::HashMap;
+use std::iter::Iterator;
+
+use winnow::ascii::alphanumeric1;
+use winnow::combinator::iterator;
+use winnow::combinator::{separated_pair, terminated};
+use winnow::prelude::*;
+
+fn main() {
+    let mut data = "abcabcabcabc";
+
+    fn parser<'s>(i: &mut &'s str) -> PResult<&'s str> {
+        "abc".parse_next(i)
+    }
+
+    // `from_fn` (available from Rust 1.34) can create an iterator
+    // from a closure
+    let it = std::iter::from_fn(move || {
+        match parser.parse_next(&mut data) {
+            // when successful, a parser returns a tuple of
+            // the remaining input and the output value.
+            // So we replace the captured input data with the
+            // remaining input, to be parsed on the next call
+            Ok(o) => Some(o),
+            _ => None,
+        }
+    });
+
+    for value in it {
+        println!("parser returned: {}", value);
+    }
+
+    println!("\n********************\n");
+
+    let mut data = "abcabcabcabc";
+
+    // if `from_fn` is not available, it is possible to fold
+    // over an iterator of functions
+    let res = std::iter::repeat(parser)
+        .take(3)
+        .try_fold(Vec::new(), |mut acc, mut parser| {
+            parser.parse_next(&mut data).map(|o| {
+                acc.push(o);
+                acc
+            })
+        });
+
+    // will print "parser iterator returned: Ok(("abc", ["abc", "abc", "abc"]))"
+    println!("\nparser iterator returned: {:?}", res);
+
+    println!("\n********************\n");
+
+    let data = "key1:value1,key2:value2,key3:value3,;";
+
+    // `winnow::combinator::iterator` will return an iterator
+    // producing the parsed values. Compared to the previous
+    // solutions:
+    // - we can work with a normal iterator like `from_fn`
+    // - we can get the remaining input afterwards, like with the `try_fold` trick
+    let mut winnow_it = iterator(
+        data,
+        terminated(separated_pair(alphanumeric1, ":", alphanumeric1), ","),
+    );
+
+    let res = winnow_it
+        .map(|(k, v)| (k.to_uppercase(), v))
+        .collect::<HashMap<_, _>>();
+
+    let parser_result: PResult<(_, _), ()> = winnow_it.finish();
+    let (remaining_input, ()) = parser_result.unwrap();
+
+    // will print "iterator returned {"key1": "value1", "key3": "value3", "key2": "value2"}, remaining input is ';'"
+    println!(
+        "iterator returned {:?}, remaining input is '{}'",
+        res, remaining_input
+    );
+}