Specialize GenericSequence and zip more

Author: suptalentdev

src/functional.rs

@@ -24,6 +24,15 @@ where
     type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
 }
 
+unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a mut S
+where
+    &'a mut S: GenericSequence<T>,
+    S: GenericSequence<T, Length=<&'a mut S as GenericSequence<T>>::Length>,
+    <S as GenericSequence<T>>::Length: ArrayLength<U>,
+{
+    type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
+}
+
 /// Accessor type for a mapped generic sequence
 pub type MappedSequence<S, T, U> = <<S as MappedGenericSequence<T, U>>::Mapped as GenericSequence<U>>::Sequence;
 
@@ -47,15 +56,16 @@ pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
     ///
     /// If the mapping function panics, any already initialized elements in the new sequence
     /// will be dropped, AND any unused elements in the source sequences will also be dropped.
-    fn zip<B, Rhs, U, F>(self, rhs: Rhs, mut f: F) -> MappedSequence<Self, T, U>
+    #[inline]
+    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
         where
             Self: MappedGenericSequence<T, U>,
             Rhs: MappedGenericSequence<B, U, Mapped=MappedSequence<Self, T, U>>,
             Self::Length: ArrayLength<B> + ArrayLength<U>,
             Rhs: GenericSequence<B, Length=Self::Length>,
             F: FnMut(SequenceItem<Self>, SequenceItem<Rhs>) -> U,
     {
-        FromIterator::from_iter(self.into_iter().zip(rhs.into_iter()).map(|(l, r)| f(l, r) ))
+        rhs.inverted_zip2(self, f)
     }
 }
 

src/lib.rs

@@ -324,6 +324,26 @@ where
             f(left_value, right_value)
         }))
     }
+
+    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
+    where
+        Lhs: GenericSequence<B, Length=Self::Length> + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(SequenceItem<Lhs>, SequenceItem<Self>) -> U
+    {
+        let mut right = ArrayConsumer::new(self);
+
+        let ArrayConsumer { array: ref right_array, position: ref mut right_position } = right;
+
+        FromIterator::from_iter(lhs.into_iter().zip(right_array.iter()).map(|(left_value, r)| {
+            let right_value = unsafe { ptr::read(r) };
+
+            *right_position += 1;
+
+            f(left_value, right_value)
+        }))
+    }
 }
 
 unsafe impl<T, U, N> MappedGenericSequence<T, U> for GenericArray<T, N>
@@ -506,9 +526,9 @@ mod test {
         use functional::*;
 
         let a = black_box(arr![i32; 1, 3, 5, 7]);
-        let b = black_box(arr![i32; 2, 4, 6, 8]);
+        let mut b = black_box(arr![i32; 2, 4, 6, 8]);
 
-        let c = a.zip(b, |l, r| l + r);
+        let c = (a).zip(&mut b, |l, r| l + *r);
 
         assert_eq!(c, arr![i32; 3, 7, 11, 15]);
     }

src/sequence.rs

@@ -45,6 +45,17 @@ pub unsafe trait GenericSequence<T>: Sized + IntoIterator {
             f(left_value, right_value)
         }))
     }
+
+    #[doc(hidden)]
+    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
+    where
+        Lhs: GenericSequence<B, Length=Self::Length> + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(SequenceItem<Lhs>, SequenceItem<Self>) -> U
+    {
+        FromIterator::from_iter(lhs.into_iter().zip(self.into_iter()).map(|(l, r)| f(l, r) ))
+    }
 }
 
 /// Accessor type for iteration items from `GenericSequence`