Add fold method to FunctionalSequence

Author: suptalentdev

src/functional.rs

@@ -43,10 +43,10 @@ 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 sequence will also be dropped.
     fn map<U, F>(self, f: F) -> MappedSequence<Self, T, U>
-        where
-            Self: MappedGenericSequence<T, U>,
-            Self::Length: ArrayLength<U>,
-            F: FnMut(SequenceItem<Self>) -> U,
+    where
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<U>,
+        F: FnMut(SequenceItem<Self>) -> U,
     {
         FromIterator::from_iter(self.into_iter().map(f))
     }
@@ -58,15 +58,25 @@ pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
     /// will be dropped, AND any unused elements in the source sequences will also be dropped.
     #[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,
+    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,
     {
         rhs.inverted_zip2(self, f)
     }
+
+    /// Folds (or reduces) a sequence of data into a single value.
+    ///
+    /// If the fold function panics, any unused elements will be dropped.
+    fn fold<U, F>(self, init: U, f: F) -> U
+    where
+        F: FnMut(U, SequenceItem<Self>) -> U,
+    {
+        self.into_iter().fold(init, f)
+    }
 }
 
 unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S

src/lib.rs

@@ -389,6 +389,23 @@ where
     {
         rhs.inverted_zip(self, f)
     }
+
+    fn fold<U, F>(self, init: U, mut f: F) -> U
+    where
+        F: FnMut(U, T) -> U
+    {
+        let mut source = ArrayConsumer::new(self);
+
+        let ArrayConsumer { ref array, ref mut position } = source;
+
+        array.iter().fold(init, |acc, src| {
+            let value = unsafe { ptr::read(src) };
+
+            *position += 1;
+
+            f(acc, value)
+        })
+    }
 }
 
 impl<T, N> GenericArray<T, N>
@@ -526,10 +543,14 @@ mod test {
         use functional::*;
 
         let a = black_box(arr![i32; 1, 3, 5, 7]);
-        let mut b = black_box(arr![i32; 2, 4, 6, 8]);
+        let 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);
+        let d = a.fold(0, |a, x| a + x);
 
         assert_eq!(c, arr![i32; 3, 7, 11, 15]);
+
+        assert_eq!(d, 16);
     }
 }

tests/mod.rs

@@ -3,7 +3,7 @@
 #[macro_use]
 extern crate generic_array;
 use core::cell::Cell;
-use core::ops::Drop;
+use core::ops::{Add, Drop};
 use generic_array::GenericArray;
 use generic_array::sequence::*;
 use generic_array::functional::*;
@@ -267,4 +267,27 @@ fn test_concat() {
 
     assert_eq!(d, arr![i32; 1]);
     assert_eq!(e, arr![i32; 2, 3, 4]);
+}
+
+#[test]
+fn test_fold() {
+    let a = arr![i32; 1, 2, 3, 4];
+
+    assert_eq!(10, a.fold(0, |a, x| a + x));
+}
+
+fn sum_generic<S>(s: S) -> i32
+where
+    S: FunctionalSequence<i32>,
+    SequenceItem<S>: Add<i32, Output=i32>, // `+`
+    i32: Add<SequenceItem<S>, Output=i32>, // reflexive
+{
+    s.fold(0, |a, x| a + x)
+}
+
+#[test]
+fn test_sum() {
+    let a = sum_generic(arr![i32; 1, 2, 3, 4]);
+
+    assert_eq!(a, 10);
 }

tests/std.rs

@@ -1,6 +1,5 @@
 #![recursion_limit="128"]
 
-//#[macro_use]
 extern crate generic_array;
 
 use std::fmt::Debug;
@@ -11,11 +10,11 @@ use generic_array::sequence::*;
 use generic_array::functional::*;
 
 pub fn test_generic<S>(s: S)
-    where
-        S: FunctionalSequence<i32>,            // `.map`
-        SequenceItem<S>: Add<i32, Output=i32>, // `+`
-        S: MappedGenericSequence<i32, i32>,    // `i32` -> `i32`
-        MappedSequence<S, i32, i32>: Debug     // println!
+where
+    S: FunctionalSequence<i32>,            // `.map`
+    SequenceItem<S>: Add<i32, Output=i32>, // `+`
+    S: MappedGenericSequence<i32, i32>,    // `i32` -> `i32`
+    MappedSequence<S, i32, i32>: Debug     // println!
 {
     let a = s.map(|x| x + 1);