bring back FunctionalSequence

See example usage:
https://github.com/RustCrypto/AEADs/blob/d1a22983d2af3c6a1ac3644850351f0ab0a77e51/eax/src/online.rs#L352

Author: baloo

src/functional.rs

@@ -0,0 +1,61 @@
+//! Functional programming with [`Array`]s.
+// This is modeled after `generic-array::functional`
+// see: <https://docs.rs/generic-array/1.0.0/generic_array/functional/index.html>
+
+use crate::{Array, ArraySize};
+
+impl<T, U> Array<T, U>
+where
+    U: ArraySize,
+{
+    /// Maps an `Array` to another `Array`
+    ///
+    /// 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, f: F) -> Array<O, U>
+    where
+        F: FnMut(T) -> O,
+    {
+        self.into_iter().map(f).collect()
+    }
+
+    /// Combines two `Array` instances and iterates through both of them, initialization a new
+    /// `Array` with the result of the zipped mapping function.
+    ///
+    /// 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>, f: F) -> Array<O, U>
+    where
+        U: ArraySize,
+        F: FnMut(T, Rhs) -> O,
+    {
+        Zipper {
+            inner: self.into_iter(),
+            rhs: rhs.into_iter(),
+            f,
+        }
+        .collect()
+    }
+}
+
+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()?))
+    }
+}

src/lib.rs

@@ -88,6 +88,7 @@
 extern crate std;
 
 mod from_fn;
+mod functional;
 mod iter;
 mod sizes;
 mod traits;

tests/mod.rs

@@ -139,3 +139,18 @@ 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);
+}