feat: make izip! temporary friendly

- some izip! calls with temporary values would not compile with the current
izip! implementation due to the use of a block to create the temporary iter
chain, if a user called izip! with an iterator from a temporary value the
compilation would fail
- this change adapts the macro to stop making use of the block and calls
$crate::__std_iter::Iterator::zip directly to avoid the need for temporary
iter bindings, this means the recursion produces a tuple of the form
(a, (b, (c, d))) instead of (((a, b), c), d), needing a slight adaptation
of the closure arm to invert the way arguments are unpacked, it also adds
two arms to recursively build the zipped iterators without the final map
adapter as we don't process all iterators at once as before

Author: IceTDrinker

src/lib.rs

@@ -321,14 +321,27 @@ macro_rules! iproduct {
 macro_rules! izip {
     // @closure creates a tuple-flattening closure for .map() call. usage:
     // @closure partial_pattern => partial_tuple , rest , of , iterators
-    // eg. izip!( @closure ((a, b), c) => (a, b, c) , dd , ee )
+    // eg. izip!( @closure (a, (b, c)) => (a, b, c) , dd , ee )
     ( @closure $p:pat => $tup:expr ) => {
         |$p| $tup
     };
 
     // The "b" identifier is a different identifier on each recursion level thanks to hygiene.
     ( @closure $p:pat => ( $($tup:tt)* ) , $_iter:expr $( , $tail:expr )* ) => {
-        $crate::izip!(@closure ($p, b) => ( $($tup)*, b ) $( , $tail )*)
+        $crate::izip!(@closure (b, $p) => ( b, $($tup)* ) $( , $tail )*)
+    };
+
+    // Inner recursion of the macro without final map adapter, base case
+    ( @ no_map @ $first:expr $(,)?) => {
+        $crate::__std_iter::IntoIterator::into_iter($first)
+    };
+
+    // Inner recursion of the macro without final map adapter, recursive case
+    ( @ no_map @ $first:expr, $($rest:expr),+ $(,)?) => {
+        $crate::__std_iter::Iterator::zip(
+            $crate::__std_iter::IntoIterator::into_iter($first),
+            $crate::izip!(@ no_map @ $($rest),+)
+        )
     };
 
     // unary
@@ -346,16 +359,13 @@ macro_rules! izip {
 
     // n-ary where n > 2
     ( $first:expr $( , $rest:expr )* $(,)* ) => {
-        {
-            let iter = $crate::__std_iter::IntoIterator::into_iter($first);
-            $(
-                let iter = $crate::__std_iter::Iterator::zip(iter, $rest);
-            )*
-            $crate::__std_iter::Iterator::map(
-                iter,
-                $crate::izip!(@closure a => (a) $( , $rest )*)
-            )
-        }
+        $crate::__std_iter::Iterator::map(
+            $crate::__std_iter::Iterator::zip(
+                $crate::__std_iter::IntoIterator::into_iter($first),
+                $crate::izip!(@ no_map @ $($rest),+)
+            ),
+            $crate::izip!(@closure a => (a) $( , $rest )*)
+        )
     };
 }
 

tests/zip.rs

@@ -54,3 +54,49 @@ fn test_double_ended_zip() {
     assert_eq!(it.next_back(), Some((1, 1)));
     assert_eq!(it.next_back(), None);
 }
+
+#[test]
+/// The purpose of this test is not really to test the iterator mechanics itself, rather that it
+/// compiles and accepts temporary values as inputs, as those would be valid when not used with the
+/// izip! macro and zipped manually via .zip calls
+fn test_izip_with_temporaries() {
+    struct Owned {
+        data: Vec<i32>,
+    }
+
+    impl Owned {
+        fn new(val: i32) -> Self {
+            Self {
+                data: vec![val; 10],
+            }
+        }
+
+        fn as_view(&self) -> View<'_> {
+            View {
+                data: self.data.as_slice(),
+            }
+        }
+    }
+
+    struct View<'a> {
+        data: &'a [i32],
+    }
+
+    impl View<'_> {
+        fn iter(&self) -> impl Iterator<Item = &i32> {
+            self.data.iter()
+        }
+    }
+
+    let a = Owned::new(0);
+    let b = Owned::new(1);
+    let c = Owned::new(2);
+
+    let mut sum = 0;
+
+    for (x, y, z) in itertools::izip!(a.as_view().iter(), b.as_view().iter(), c.as_view().iter()) {
+        sum += x + y + z;
+    }
+
+    assert_eq!(sum, 30);
+}