@aztec/protocol-contracts 3.0.0-nightly.20251126 → 3.0.0-nightly.20251128

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. package/artifacts/AuthRegistry.json +6 -6
  2. package/artifacts/ContractClassRegistry.json +5 -5
  3. package/artifacts/ContractInstanceRegistry.json +5 -5
  4. package/artifacts/FeeJuice.json +5 -5
  5. package/artifacts/MultiCallEntrypoint.json +6 -6
  6. package/artifacts/Router.json +5 -5
  7. package/dest/auth-registry/index.d.ts +1 -1
  8. package/dest/auth-registry/lazy.d.ts +1 -1
  9. package/dest/class-registry/contract_class_published_event.d.ts +1 -1
  10. package/dest/class-registry/contract_class_published_event.d.ts.map +1 -1
  11. package/dest/class-registry/index.d.ts +1 -1
  12. package/dest/class-registry/lazy.d.ts +1 -1
  13. package/dest/class-registry/private_function_broadcasted_event.d.ts +1 -5
  14. package/dest/class-registry/private_function_broadcasted_event.d.ts.map +1 -1
  15. package/dest/class-registry/utility_function_broadcasted_event.d.ts +1 -4
  16. package/dest/class-registry/utility_function_broadcasted_event.d.ts.map +1 -1
  17. package/dest/fee-juice/index.d.ts +1 -1
  18. package/dest/fee-juice/lazy.d.ts +1 -1
  19. package/dest/index.d.ts +1 -1
  20. package/dest/instance-registry/contract_instance_published_event.d.ts +1 -1
  21. package/dest/instance-registry/contract_instance_published_event.d.ts.map +1 -1
  22. package/dest/instance-registry/contract_instance_updated_event.d.ts +1 -1
  23. package/dest/instance-registry/contract_instance_updated_event.d.ts.map +1 -1
  24. package/dest/instance-registry/index.d.ts +1 -1
  25. package/dest/instance-registry/lazy.d.ts +1 -1
  26. package/dest/make_protocol_contract.d.ts +1 -1
  27. package/dest/multi-call-entrypoint/index.d.ts +1 -1
  28. package/dest/multi-call-entrypoint/lazy.d.ts +1 -1
  29. package/dest/protocol_contract.d.ts +1 -1
  30. package/dest/protocol_contract_data.d.ts +1 -1
  31. package/dest/provider/bundle.d.ts +1 -1
  32. package/dest/provider/bundle.d.ts.map +1 -1
  33. package/dest/provider/lazy.d.ts +1 -1
  34. package/dest/provider/lazy.d.ts.map +1 -1
  35. package/dest/provider/protocol_contracts_provider.d.ts +1 -1
  36. package/dest/router/index.d.ts +1 -1
  37. package/dest/router/lazy.d.ts +1 -1
  38. package/dest/tests/fixtures.d.ts +1 -1
  39. package/package.json +9 -8
package/artifacts/FeeJuice.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "transpiled": true,
3
- "noir_version": "1.0.0-beta.15+881acee6c8df42adb85ff0b9bc9ad144b43bdf6b",
3
+ "noir_version": "1.0.0-beta.15+1a930357477fc0c210dc5a8960680282d4cfa24e",
4
4
  "name": "FeeJuice",
5
5
  "functions": [
6
6
  {
@@ -4117,7 +4117,7 @@
4117
4117
  }
4118
4118
  },
4119
4119
  "bytecode": "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",
4120
- "debug_symbols": "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"
4120
+ "debug_symbols": "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"
4121
4121
  },
4122
4122
  {
4123
4123
  "name": "public_dispatch",
@@ -4339,7 +4339,7 @@
4339
4339
  }
4340
4340
  },
4341
4341
  "bytecode": "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",
4342
- "debug_symbols": "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"
4342
+ "debug_symbols": "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"
4343
4343
  }
4344
4344
  ],
4345
4345
  "outputs": {
@@ -4865,7 +4865,7 @@
4865
4865
  },
4866
4866
  "3": {
4867
4867
  "path": "std/array/mod.nr",
4868
- "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
4868
+ "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the [`Self::sort_via`] function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let mut arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
4869
4869
  },
4870
4870
  "322": {
4871
4871
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
@@ -4945,7 +4945,7 @@
4945
4945
  },
4946
4946
  "6": {
4947
4947
  "path": "std/collections/bounded_vec.nr",
4948
- "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec<Field, 10> {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec<Field, 3> = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0, \"cannot pop from an empty vector\");\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if !exceeded_len {\n ret |= predicate(self.storage[i]);\n }\n }\n }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n let _ = vec.get(0);\n }\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_beyond_length() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n let _ = vec.get(3);\n }\n\n #[test]\n fn get_works_within_bounds() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(2), 3);\n assert_eq(vec.get(4), 5);\n }\n\n #[test]\n fn get_unchecked_works() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n assert_eq(vec.get_unchecked(0), 1);\n assert_eq(vec.get_unchecked(2), 3);\n }\n\n #[test]\n fn get_unchecked_works_past_len() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n assert_eq(vec.get_unchecked(4), 0);\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n vec.set(0, 42);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_setting_beyond_length() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n vec.set(3, 4);\n }\n\n #[test]\n fn set_unchecked_operations() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n vec.set_unchecked(0, 10);\n assert_eq(vec.get(0), 10);\n }\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn set_unchecked_operations_past_len() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n vec.set_unchecked(3, 40);\n assert_eq(vec.get(3), 40);\n }\n\n #[test]\n fn set_preserves_other_elements() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n vec.set(2, 30);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 30);\n assert_eq(vec.get(3), 4);\n assert_eq(vec.get(4), 5);\n }\n }\n\n mod any {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn returns_false_if_predicate_not_satisfied() {\n let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, false, false]);\n let result = vec.any(|value| value);\n\n assert(!result);\n }\n\n #[test]\n fn returns_true_if_predicate_satisfied() {\n let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, true, true]);\n let result = vec.any(|value| value);\n\n assert(result);\n }\n\n #[test]\n fn returns_false_on_empty_boundedvec() {\n let vec: BoundedVec<bool, 0> = BoundedVec::new();\n let result = vec.any(|value| value);\n\n assert(!result);\n }\n\n #[test]\n fn any_with_complex_predicates() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n assert(vec.any(|x| x > 3));\n assert(!vec.any(|x| x > 10));\n assert(vec.any(|x| x % 2 == 0)); // has a even number\n assert(vec.any(|x| x == 3)); // has a specific value\n }\n\n #[test]\n fn any_with_partial_vector() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n assert(vec.any(|x| x == 1));\n assert(vec.any(|x| x == 2));\n assert(!vec.any(|x| x == 3));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn map_with_conditional_logic() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n let result = vec.map(|x| if x % 2 == 0 { x * 2 } else { x });\n let expected = BoundedVec::from_array([1, 4, 3, 8]);\n assert_eq(result, expected);\n }\n\n #[test]\n fn map_preserves_length() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|x| x * 2);\n\n assert_eq(result.len(), vec.len());\n assert_eq(result.max_len(), vec.max_len());\n }\n\n #[test]\n fn map_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let result = vec.map(|x| x * 2);\n assert_eq(result, vec);\n assert_eq(result.len(), 0);\n assert_eq(result.max_len(), 5);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn mapi_with_index_branching_logic() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n let result = vec.mapi(|i, x| if i % 2 == 0 { x * 2 } else { x });\n let expected = BoundedVec::from_array([2, 2, 6, 4]);\n assert_eq(result, expected);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn for_each_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let mut count = 0;\n let count_ref = &mut count;\n vec.for_each(|_| { *count_ref += 1; });\n assert_eq(count, 0);\n }\n\n #[test]\n fn for_each_with_side_effects() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n let mut seen = BoundedVec::<u32, 3>::new();\n let seen_ref = &mut seen;\n vec.for_each(|x| seen_ref.push(x));\n assert_eq(seen, vec);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn for_eachi_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let mut count = 0;\n let count_ref = &mut count;\n vec.for_eachi(|_, _| { *count_ref += 1; });\n assert_eq(count, 0);\n }\n\n #[test]\n fn for_eachi_with_index_tracking() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([10, 20, 30]);\n let mut indices = BoundedVec::<u32, 3>::new();\n let indices_ref = &mut indices;\n vec.for_eachi(|i, _| indices_ref.push(i));\n\n let expected = BoundedVec::from_array([0, 1, 2]);\n assert_eq(indices, expected);\n }\n\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n }\n\n #[test]\n fn from_array_preserves_order() {\n let array = [5, 3, 1, 4, 2];\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array(array);\n for i in 0..array.len() {\n assert_eq(vec.get(i), array[i]);\n }\n }\n\n #[test]\n fn from_array_with_different_types() {\n let bool_array = [true, false, true];\n let bool_vec: BoundedVec<bool, 3> = BoundedVec::from_array(bool_array);\n assert_eq(bool_vec.len(), 3);\n assert_eq(bool_vec.get(0), true);\n assert_eq(bool_vec.get(1), false);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n\n mod push_pop {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn push_and_pop_operations() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n assert_eq(vec.len(), 0);\n\n vec.push(1);\n assert_eq(vec.len(), 1);\n assert_eq(vec.get(0), 1);\n\n vec.push(2);\n assert_eq(vec.len(), 2);\n assert_eq(vec.get(1), 2);\n\n let popped = vec.pop();\n assert_eq(popped, 2);\n assert_eq(vec.len(), 1);\n\n let popped2 = vec.pop();\n assert_eq(popped2, 1);\n assert_eq(vec.len(), 0);\n }\n\n #[test(should_fail_with = \"push out of bounds\")]\n fn push_to_full_vector() {\n let mut vec: BoundedVec<u32, 2> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n vec.push(3); // should panic\n }\n\n #[test(should_fail_with = \"cannot pop from an empty vector\")]\n fn pop_from_empty_vector() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n let _ = vec.pop(); // should panic\n }\n\n #[test]\n fn push_pop_cycle() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n\n // push to full\n vec.push(1);\n vec.push(2);\n vec.push(3);\n assert_eq(vec.len(), 3);\n\n // pop all\n assert_eq(vec.pop(), 3);\n assert_eq(vec.pop(), 2);\n assert_eq(vec.pop(), 1);\n assert_eq(vec.len(), 0);\n\n // push again\n vec.push(4);\n assert_eq(vec.len(), 1);\n assert_eq(vec.get(0), 4);\n }\n }\n\n mod extend {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn extend_from_array() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_array([2, 3]);\n\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n\n #[test]\n fn extend_from_slice() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_slice(&[2, 3]);\n\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n\n #[test]\n fn extend_from_bounded_vec() {\n let mut vec1: BoundedVec<u32, 5> = BoundedVec::new();\n let mut vec2: BoundedVec<u32, 3> = BoundedVec::new();\n\n vec1.push(1);\n vec2.push(2);\n vec2.push(3);\n\n vec1.extend_from_bounded_vec(vec2);\n\n assert_eq(vec1.len(), 3);\n assert_eq(vec1.get(0), 1);\n assert_eq(vec1.get(1), 2);\n assert_eq(vec1.get(2), 3);\n }\n\n #[test(should_fail_with = \"extend_from_array out of bounds\")]\n fn extend_array_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_array([2, 3, 4]); // should panic\n }\n\n #[test(should_fail_with = \"extend_from_slice out of bounds\")]\n fn extend_slice_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_slice(&[2, 3, 4]); // S]should panic\n }\n\n #[test(should_fail_with = \"extend_from_bounded_vec out of bounds\")]\n fn extend_bounded_vec_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n let other: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n vec.extend_from_bounded_vec(other); // should panic\n }\n\n #[test]\n fn extend_with_empty_collections() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n let original_len = vec.len();\n\n vec.extend_from_array([]);\n assert_eq(vec.len(), original_len);\n\n vec.extend_from_slice(&[]);\n assert_eq(vec.len(), original_len);\n\n let empty: BoundedVec<u32, 3> = BoundedVec::new();\n vec.extend_from_bounded_vec(empty);\n assert_eq(vec.len(), original_len);\n }\n }\n\n mod storage {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn storage_consistency() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n // test initial storage state\n assert_eq(vec.storage(), [0, 0, 0, 0, 0]);\n\n vec.push(1);\n vec.push(2);\n\n // test storage after modifications\n assert_eq(vec.storage(), [1, 2, 0, 0, 0]);\n\n // storage doesn't change length\n assert_eq(vec.len(), 2);\n assert_eq(vec.max_len(), 5);\n }\n\n #[test]\n fn storage_after_pop() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n\n let _ = vec.pop();\n // after pop, the last element should be zeroed\n assert_eq(vec.storage(), [1, 2, 0]);\n assert_eq(vec.len(), 2);\n }\n\n #[test]\n fn vector_immutable() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n let storage = vec.storage();\n\n assert_eq(storage, [1, 2, 3]);\n\n // Verify that the original vector is unchanged\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n }\n}\n"
4948
+ "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a [`Vec`][crate::collections::vec::Vec]`<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec<Field, 10> {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec<Field, 3> = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0, \"cannot pop from an empty vector\");\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if !exceeded_len {\n ret |= predicate(self.storage[i]);\n }\n }\n }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use [`from_parts_unchecked`][Self::from_parts_unchecked] to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n let _ = vec.get(0);\n }\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_beyond_length() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n let _ = vec.get(3);\n }\n\n #[test]\n fn get_works_within_bounds() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(2), 3);\n assert_eq(vec.get(4), 5);\n }\n\n #[test]\n fn get_unchecked_works() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n assert_eq(vec.get_unchecked(0), 1);\n assert_eq(vec.get_unchecked(2), 3);\n }\n\n #[test]\n fn get_unchecked_works_past_len() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n assert_eq(vec.get_unchecked(4), 0);\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n vec.set(0, 42);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_setting_beyond_length() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n vec.set(3, 4);\n }\n\n #[test]\n fn set_unchecked_operations() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n vec.set_unchecked(0, 10);\n assert_eq(vec.get(0), 10);\n }\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn set_unchecked_operations_past_len() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n vec.set_unchecked(3, 40);\n assert_eq(vec.get(3), 40);\n }\n\n #[test]\n fn set_preserves_other_elements() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n vec.set(2, 30);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 30);\n assert_eq(vec.get(3), 4);\n assert_eq(vec.get(4), 5);\n }\n }\n\n mod any {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn returns_false_if_predicate_not_satisfied() {\n let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, false, false]);\n let result = vec.any(|value| value);\n\n assert(!result);\n }\n\n #[test]\n fn returns_true_if_predicate_satisfied() {\n let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, true, true]);\n let result = vec.any(|value| value);\n\n assert(result);\n }\n\n #[test]\n fn returns_false_on_empty_boundedvec() {\n let vec: BoundedVec<bool, 0> = BoundedVec::new();\n let result = vec.any(|value| value);\n\n assert(!result);\n }\n\n #[test]\n fn any_with_complex_predicates() {\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n assert(vec.any(|x| x > 3));\n assert(!vec.any(|x| x > 10));\n assert(vec.any(|x| x % 2 == 0)); // has a even number\n assert(vec.any(|x| x == 3)); // has a specific value\n }\n\n #[test]\n fn any_with_partial_vector() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n\n assert(vec.any(|x| x == 1));\n assert(vec.any(|x| x == 2));\n assert(!vec.any(|x| x == 3));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn map_with_conditional_logic() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n let result = vec.map(|x| if x % 2 == 0 { x * 2 } else { x });\n let expected = BoundedVec::from_array([1, 4, 3, 8]);\n assert_eq(result, expected);\n }\n\n #[test]\n fn map_preserves_length() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|x| x * 2);\n\n assert_eq(result.len(), vec.len());\n assert_eq(result.max_len(), vec.max_len());\n }\n\n #[test]\n fn map_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let result = vec.map(|x| x * 2);\n assert_eq(result, vec);\n assert_eq(result.len(), 0);\n assert_eq(result.max_len(), 5);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn mapi_with_index_branching_logic() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n let result = vec.mapi(|i, x| if i % 2 == 0 { x * 2 } else { x });\n let expected = BoundedVec::from_array([2, 2, 6, 4]);\n assert_eq(result, expected);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn for_each_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let mut count = 0;\n let count_ref = &mut count;\n vec.for_each(|_| { *count_ref += 1; });\n assert_eq(count, 0);\n }\n\n #[test]\n fn for_each_with_side_effects() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n let mut seen = BoundedVec::<u32, 3>::new();\n let seen_ref = &mut seen;\n vec.for_each(|x| seen_ref.push(x));\n assert_eq(seen, vec);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n\n #[test]\n fn for_eachi_on_empty_vector() {\n let vec: BoundedVec<u32, 5> = BoundedVec::new();\n let mut count = 0;\n let count_ref = &mut count;\n vec.for_eachi(|_, _| { *count_ref += 1; });\n assert_eq(count, 0);\n }\n\n #[test]\n fn for_eachi_with_index_tracking() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([10, 20, 30]);\n let mut indices = BoundedVec::<u32, 3>::new();\n let indices_ref = &mut indices;\n vec.for_eachi(|i, _| indices_ref.push(i));\n\n let expected = BoundedVec::from_array([0, 1, 2]);\n assert_eq(indices, expected);\n }\n\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n }\n\n #[test]\n fn from_array_preserves_order() {\n let array = [5, 3, 1, 4, 2];\n let vec: BoundedVec<u32, 5> = BoundedVec::from_array(array);\n for i in 0..array.len() {\n assert_eq(vec.get(i), array[i]);\n }\n }\n\n #[test]\n fn from_array_with_different_types() {\n let bool_array = [true, false, true];\n let bool_vec: BoundedVec<bool, 3> = BoundedVec::from_array(bool_array);\n assert_eq(bool_vec.len(), 3);\n assert_eq(bool_vec.get(0), true);\n assert_eq(bool_vec.get(1), false);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n\n mod push_pop {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn push_and_pop_operations() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n assert_eq(vec.len(), 0);\n\n vec.push(1);\n assert_eq(vec.len(), 1);\n assert_eq(vec.get(0), 1);\n\n vec.push(2);\n assert_eq(vec.len(), 2);\n assert_eq(vec.get(1), 2);\n\n let popped = vec.pop();\n assert_eq(popped, 2);\n assert_eq(vec.len(), 1);\n\n let popped2 = vec.pop();\n assert_eq(popped2, 1);\n assert_eq(vec.len(), 0);\n }\n\n #[test(should_fail_with = \"push out of bounds\")]\n fn push_to_full_vector() {\n let mut vec: BoundedVec<u32, 2> = BoundedVec::new();\n vec.push(1);\n vec.push(2);\n vec.push(3); // should panic\n }\n\n #[test(should_fail_with = \"cannot pop from an empty vector\")]\n fn pop_from_empty_vector() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n let _ = vec.pop(); // should panic\n }\n\n #[test]\n fn push_pop_cycle() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n\n // push to full\n vec.push(1);\n vec.push(2);\n vec.push(3);\n assert_eq(vec.len(), 3);\n\n // pop all\n assert_eq(vec.pop(), 3);\n assert_eq(vec.pop(), 2);\n assert_eq(vec.pop(), 1);\n assert_eq(vec.len(), 0);\n\n // push again\n vec.push(4);\n assert_eq(vec.len(), 1);\n assert_eq(vec.get(0), 4);\n }\n }\n\n mod extend {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn extend_from_array() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_array([2, 3]);\n\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n\n #[test]\n fn extend_from_slice() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_slice(&[2, 3]);\n\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n\n #[test]\n fn extend_from_bounded_vec() {\n let mut vec1: BoundedVec<u32, 5> = BoundedVec::new();\n let mut vec2: BoundedVec<u32, 3> = BoundedVec::new();\n\n vec1.push(1);\n vec2.push(2);\n vec2.push(3);\n\n vec1.extend_from_bounded_vec(vec2);\n\n assert_eq(vec1.len(), 3);\n assert_eq(vec1.get(0), 1);\n assert_eq(vec1.get(1), 2);\n assert_eq(vec1.get(2), 3);\n }\n\n #[test(should_fail_with = \"extend_from_array out of bounds\")]\n fn extend_array_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_array([2, 3, 4]); // should panic\n }\n\n #[test(should_fail_with = \"extend_from_slice out of bounds\")]\n fn extend_slice_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n vec.push(1);\n vec.extend_from_slice(&[2, 3, 4]); // S]should panic\n }\n\n #[test(should_fail_with = \"extend_from_bounded_vec out of bounds\")]\n fn extend_bounded_vec_beyond_max_len() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n let other: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n vec.extend_from_bounded_vec(other); // should panic\n }\n\n #[test]\n fn extend_with_empty_collections() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n let original_len = vec.len();\n\n vec.extend_from_array([]);\n assert_eq(vec.len(), original_len);\n\n vec.extend_from_slice(&[]);\n assert_eq(vec.len(), original_len);\n\n let empty: BoundedVec<u32, 3> = BoundedVec::new();\n vec.extend_from_bounded_vec(empty);\n assert_eq(vec.len(), original_len);\n }\n }\n\n mod storage {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn storage_consistency() {\n let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n // test initial storage state\n assert_eq(vec.storage(), [0, 0, 0, 0, 0]);\n\n vec.push(1);\n vec.push(2);\n\n // test storage after modifications\n assert_eq(vec.storage(), [1, 2, 0, 0, 0]);\n\n // storage doesn't change length\n assert_eq(vec.len(), 2);\n assert_eq(vec.max_len(), 5);\n }\n\n #[test]\n fn storage_after_pop() {\n let mut vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n\n let _ = vec.pop();\n // after pop, the last element should be zeroed\n assert_eq(vec.storage(), [1, 2, 0]);\n assert_eq(vec.len(), 2);\n }\n\n #[test]\n fn vector_immutable() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n let storage = vec.storage();\n\n assert_eq(storage, [1, 2, 3]);\n\n // Verify that the original vector is unchanged\n assert_eq(vec.len(), 3);\n assert_eq(vec.get(0), 1);\n assert_eq(vec.get(1), 2);\n assert_eq(vec.get(2), 3);\n }\n }\n}\n"
4949
4949
  },
4950
4950
  "61": {
4951
4951
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",