remove unsafe code

Author: baloo

src/functional.rs

@@ -13,17 +13,14 @@ where
     /// If the mapping function panics, any already initialized elements in the new array will
     /// be dropped, AND any unused elements in the source array will also be dropped.
     #[inline(always)]
-    pub fn map<O, F>(self, mut f: F) -> Array<O, U>
+    pub fn map<O, F>(self, f: F) -> Array<O, U>
     where
         F: FnMut(T) -> O,
     {
-        let mut out = Array::uninit();
-
-        for (i, s) in self.into_iter().enumerate() {
-            out[i].write(f(s));
-        }
-
-        unsafe { out.assume_init() }
+        Array::from_iter(Mapper {
+            inner: self.into_iter(),
+            f,
+        })
     }
 
     /// Combines two `Array` instances and iterates through both of them, initialization a new
@@ -32,21 +29,16 @@ where
     /// If the mapping function panics, any already initialized elements in the new array will
     /// be dropped, AND any unused elements in the source arrays will also be dropped.
     #[inline(always)]
-    pub fn zip<Rhs, F, O>(self, rhs: Array<Rhs, U>, mut f: F) -> Array<O, U>
+    pub fn zip<Rhs, F, O>(self, rhs: Array<Rhs, U>, f: F) -> Array<O, U>
     where
         U: ArraySize,
         F: FnMut(T, Rhs) -> O,
     {
-        let mut out = Array::uninit();
-
-        let mut s = self.into_iter().enumerate();
-        let mut r = rhs.into_iter();
-
-        while let (Some((i, s)), Some(r)) = (s.next(), r.next()) {
-            out[i].write(f(s, r));
-        }
-
-        unsafe { out.assume_init() }
+        Array::from_iter(Zipper {
+            inner: self.into_iter(),
+            rhs: rhs.into_iter(),
+            f,
+        })
     }
 
     /// Folds (or reduces) a sequence of data into a single value.
@@ -64,3 +56,41 @@ where
         init
     }
 }
+
+struct Mapper<I, F> {
+    inner: I,
+    f: F,
+}
+
+impl<I, T, O, F> Iterator for Mapper<I, F>
+where
+    I: Iterator<Item = T>,
+    F: FnMut(T) -> O,
+{
+    type Item = O;
+
+    #[inline(always)]
+    fn next(&mut self) -> Option<Self::Item> {
+        Some((self.f)(self.inner.next()?))
+    }
+}
+
+struct Zipper<I, R, F> {
+    inner: I,
+    rhs: R,
+    f: F,
+}
+
+impl<I, T, R, RT, O, F> Iterator for Zipper<I, R, F>
+where
+    I: Iterator<Item = T>,
+    R: Iterator<Item = RT>,
+    F: FnMut(T, RT) -> O,
+{
+    type Item = O;
+
+    #[inline(always)]
+    fn next(&mut self) -> Option<Self::Item> {
+        Some((self.f)(self.inner.next()?, self.rhs.next()?))
+    }
+}

tests/mod.rs

@@ -139,3 +139,24 @@ fn maybe_uninit() {
     let array = unsafe { uninit_array.assume_init() };
     assert_eq!(array.as_slice(), EXAMPLE_SLICE);
 }
+
+#[test]
+fn test_functional_map() {
+    let base = Array::<u8, U4>::from([1, 2, 3, 4]);
+    let expected = Array::<u8, U4>::from([2, 3, 4, 5]);
+    assert_eq!(base.map(|item| item + 1), expected);
+}
+
+#[test]
+fn test_functional_zip() {
+    let base = Array::<u8, U4>::from([1, 2, 3, 4]);
+    let with = Array::<u8, U4>::from([2, 3, 4, 5]);
+    let expected = Array::<u8, U4>::from([2, 6, 12, 20]);
+    assert_eq!(base.zip(with, |item, rhs| item * rhs), expected);
+}
+
+#[test]
+fn test_functional_fold() {
+    let base = Array::<u8, U4>::from([1, 2, 3, 4]);
+    assert_eq!(base.fold(0, |acc, item| acc + item), 10);
+}