chore: add mapi/for_eachi functions (#7705)

Author: michaeljklein

cspell.json

@@ -88,6 +88,7 @@
         "desugared",
         "devcontainer",
         "direnv",
+        "eachi",
         "eddsa",
         "elab",
         "Elligator",
@@ -143,6 +144,7 @@
         "losslessly",
         "lvalue",
         "Maddiaa",
+        "mapi",
         "mathbb",
         "memfs",
         "memset",

docs/docs/noir/concepts/data_types/arrays.md

@@ -164,6 +164,65 @@ let a = [1, 2, 3];
 let b = a.map(|a| a * 2); // b is now [2, 4, 6]
 ```
 
+### mapi
+
+Applies a function to each element of the array, along with its index in the
+array, returning a new array containing the mapped elements.
+
+```rust
+fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.mapi(|i, a| i + a * 2); // b is now [2, 5, 8]
+```
+
+### for_each
+
+Applies a function to each element of the array.
+
+```rust
+fn for_each<Env>(self, f: fn[Env](T) -> ())
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+a.for_each(|x| {
+    println(f"{x}");
+});
+// prints:
+// 1
+// 2
+// 3
+```
+
+### for_eachi
+
+Applies a function to each element of the array, along with its index in the
+array.
+
+```rust
+fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ())
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+a.for_eachi(|i, x| {
+    println(f"{i}, {x}");
+});
+// prints:
+// 0, 1
+// 1, 2
+// 2, 3
+```
+
 ### fold
 
 Applies a function to each element of the array, returning the final accumulated value. The first

docs/docs/noir/concepts/data_types/slices.mdx

@@ -207,6 +207,65 @@ let a = &[1, 2, 3];
 let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
 ```
 
+### mapi
+
+Applies a function to each element of the slice, along with its index in the
+slice, returning a new slice containing the mapped elements.
+
+```rust
+fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.mapi(|i, a| i + a * 2); // b is now &[2, 5, 8]
+```
+
+### for_each
+
+Applies a function to each element of the slice.
+
+```rust
+fn for_each<Env>(self, f: fn[Env](T) -> ())
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+a.for_each(|x| {
+    println(f"{x}");
+});
+// prints:
+// 1
+// 2
+// 3
+```
+
+### for_eachi
+
+Applies a function to each element of the slice, along with its index in the
+slice.
+
+```rust
+fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ())
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+a.for_eachi(|i, x| {
+    println(f"{i}, {x}");
+});
+// prints:
+// 0, 1
+// 1, 2
+// 2, 3
+```
+
 ### fold
 
 Applies a function to each element of the slice, returning the final accumulated value. The first

docs/docs/noir/standard_library/containers/boundedvec.md

@@ -294,6 +294,43 @@ Example:
 
 #include_code bounded-vec-map-example noir_stdlib/src/collections/bounded_vec.nr rust
 
+### mapi
+
+```rust
+pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this
+vector, along with its index in the vector.
+
+Example:
+
+#include_code bounded-vec-mapi-example noir_stdlib/src/collections/bounded_vec.nr rust
+
+### for_each
+
+```rust
+pub fn for_each<Env>(self, f: fn[Env](T) -> ())
+```
+
+Calls a closure on each element in this vector.
+
+Example:
+
+#include_code bounded-vec-for-each-example noir_stdlib/src/collections/bounded_vec.nr rust
+
+### for_eachi
+
+```rust
+pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ())
+```
+
+Calls a closure on each element in this vector, along with its index in the vector.
+
+Example:
+
+#include_code bounded-vec-for-eachi-example noir_stdlib/src/collections/bounded_vec.nr rust
+
 ### any
 
 ```rust

noir_stdlib/src/array/mod.nr

@@ -53,6 +53,65 @@ impl<T, let N: u32> [T; N] {
         ret
     }
 
+    /// Applies a function to each element of this array along with its index,
+    /// returning a new array containing the mapped elements.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// let a = [1, 2, 3];
+    /// let b = a.mapi(|i, a| i + a * 2);
+    /// assert_eq(b, [2, 5, 8]);
+    /// ```
+    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {
+        let uninitialized = crate::mem::zeroed();
+        let mut ret = [uninitialized; N];
+
+        for i in 0..self.len() {
+            ret[i] = f(i, self[i]);
+        }
+
+        ret
+    }
+
+    /// Applies a function to each element of this array.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// let a = [1, 2, 3];
+    /// let mut b = [0; 3];
+    /// let mut i = 0;
+    /// a.for_each(|x| {
+    ///     b[i] = x;
+    ///     i += 1;
+    /// });
+    /// assert_eq(a, b);
+    /// ```
+    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {
+        for i in 0..self.len() {
+            f(self[i]);
+        }
+    }
+
+    /// Applies a function to each element of this array along with its index.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// let a = [1, 2, 3];
+    /// let mut b = [0; 3];
+    /// a.for_eachi(|i, x| {
+    ///     b[i] = x;
+    /// });
+    /// assert_eq(a, b);
+    /// ```
+    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {
+        for i in 0..self.len() {
+            f(i, self[i]);
+        }
+    }
+
     /// Applies a function to each element of the array, returning the final accumulated value. The first
     /// parameter is the initial value.
     ///
@@ -256,6 +315,61 @@ mod test {
         assert_eq([].map(|x| x + 1), []);
     }
 
+    #[test]
+    fn mapi_empty() {
+        assert_eq([].mapi(|i, x| i * x + 1), []);
+    }
+
+    #[test]
+    fn for_each_empty() {
+        let empty_array: [Field; 0] = [];
+        empty_array.for_each(|_x| assert(false));
+    }
+
+    #[test]
+    fn for_eachi_empty() {
+        let empty_array: [Field; 0] = [];
+        empty_array.for_eachi(|_i, _x| assert(false));
+    }
+
+    #[test]
+    fn map_example() {
+        let a = [1, 2, 3];
+        let b = a.map(|a| a * 2);
+        assert_eq(b, [2, 4, 6]);
+    }
+
+    #[test]
+    fn mapi_example() {
+        let a = [1, 2, 3];
+        let b = a.mapi(|i, a| i + a * 2);
+        assert_eq(b, [2, 5, 8]);
+    }
+
+    #[test]
+    fn for_each_example() {
+        let a = [1, 2, 3];
+        let mut b = [0, 0, 0];
+        let b_ref = &mut b;
+        let mut i = 0;
+        let i_ref = &mut i;
+        a.for_each(|x| {
+            b_ref[*i_ref] = x * 2;
+            *i_ref += 1;
+        });
+        assert_eq(b, [2, 4, 6]);
+        assert_eq(i, 3);
+    }
+
+    #[test]
+    fn for_eachi_example() {
+        let a = [1, 2, 3];
+        let mut b = [0, 0, 0];
+        let b_ref = &mut b;
+        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });
+        assert_eq(b, [2, 5, 8]);
+    }
+
     #[test]
     fn concat() {
         let arr1 = [1, 2, 3, 4];