DynamicArray: support reverse feature with optional indexed forEach function

Author: querolita

src/lib/provable/dynamic-array.ts

@@ -270,18 +270,40 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
     return newArray;
   }
 
+  forEach(f: (t: ProvableValue, isDummy: Bool) => void): void;
+  forEach(f: (t: ProvableValue, isDummy: Bool, i: number) => void): void;
   /**
    * Iterate over all elements of the array.
    *
    * The callback will be passed an element and a boolean `isDummy` indicating
-   * whether the value is part of the actual array.
+   * whether the value is part of the actual array. Optionally, an index can be
+   * passed as a third argument (used in `forEachReversed`)
    */
-  forEach(f: (t: ProvableValue, isDummy: Bool) => void) {
-    zip(this.array, this.#dummyMask()).forEach(([t, isDummy]) => {
-      f(t, isDummy);
+  forEach(f: (...args: any[]) => void): void {
+    zip(this.array, this.#dummyMask()).forEach(([t, isDummy], i) => {
+      if (f.length === 2) {
+        f(t, isDummy);
+      } else {
+        f(t, isDummy, i); 
+      }
     });
   }
 
+  /**
+   * Iterate over all elements of the array, in reverse order.
+   *
+   * The callback will be passed an element and a boolean `isDummy` indicating whether the value is part of the actual array.
+   *
+   * Note: the indices are also passed in reverse order, i.e. we always have `t = this.array[i]`.
+   */
+  forEachReverse(f: (t: ProvableValue, isDummy: Bool, i: number) => void) {
+    zip(this.array, this.#dummyMask())
+      .reverse()
+      .forEach(([t, isDummy], i) => {
+        f(t, isDummy, this.capacity - 1 - i);
+      });
+  }
+
   /**
    * Return a version of the same array with a larger capacity.
    *
@@ -519,6 +541,21 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
     return sliced;
   }
 
+  /**
+   * Returns a new array with the elements reversed.
+   */
+  reverse(): DynamicArray<ProvableValue, Value> {
+    let Array = DynamicArray(this.innerType, { capacity: this.capacity });
+    // first, copy the inner array of length capacity and reverse it
+    let array = this.array.slice().reverse();
+
+    // now, slice off the padding that is now at the beginning of the array
+    let capacity = new Field(this.capacity);
+    return new Array(array, capacity).slice(
+      capacity.sub(this.length).seal()
+    );
+  }
+
   /**
    * Concatenates the current array with another dynamic array, returning a new
    * dynamic array with the values of both arrays. The capacity of the new array

src/lib/provable/test/dynamic-array.unit-test.ts

@@ -581,6 +581,14 @@ import { Provable } from '../provable.js';
           // Checking inclusion of elements
           assert(bytes.includes(new UInt8(1)));
           assert(bytes.includes(new UInt8(20)).not());
+
+          // Reverse the array
+          let reversed = bytes.reverse();
+          for (let i = 0; i < 8; i++) {
+            assert(reversed.get(new Field(i)).value.equals(new Field(8 - i)));
+            // the original array is not modified
+            assert(bytes.get(new Field(i)).value.equals(new Field(i + 1)));
+          }
         },
       },
     },