Add Array::windows

Author: lzm-build

builtin/array.mbt

@@ -1639,6 +1639,47 @@ pub fn Array::chunk_by[T](
   chunks
 }
 
+///|
+/// Generates consecutive overlapping subarrays of the specified window size.
+///
+/// Parameters:
+///
+/// * `array` : The array to be processed with sliding windows.
+/// * `size` : The window length. Must be a positive integer.
+///
+/// Returns an array of subarrays, where each subarray contains size consecutive elements
+/// starting from successive positions. Consecutive windows overlap by all but one element.
+/// If the input array's length is less than the window size, no valid windows are produced
+/// and the result is an empty array.
+///
+/// Example:
+///
+/// ```moonbit
+/// test "windows" {
+///   let arr = [1, 2, 3, 4, 5]
+///   let windows = arr.windows(2)
+///   inspect!(windows, content="[[1, 2], [2, 3], [3, 4], [4, 5]]")
+/// }
+///
+/// test "empty_windows" {
+///   let arr : Array[Int] = [1, 2]
+///   inspect!(arr.windows(3), content="[]")
+/// }
+/// ```
+pub fn Array::windows[T](self : Array[T], size : Int) -> Array[Array[T]] {
+  let capacity = self.length() - size + 1
+  if capacity < 1 {
+    return []
+  }
+  let windows = Array::new(capacity~)
+  for i in 0..<capacity {
+    let window = Array::make_uninit(size)
+    Array::unsafe_blit(window, 0, self, i, size)
+    windows.push(window)
+  }
+  windows
+}
+
 ///|
 /// Splits an array into chunks using a predicate function. Creates chunks by
 /// grouping consecutive elements that do not satisfy the predicate function.

builtin/array_test.mbt

@@ -494,6 +494,18 @@ test "chunks_by" {
   )
 }
 
+///|
+test "array_windows" {
+  let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+  let windows = arr.windows(11)
+  assert_eq!(windows.length(), 0)
+  let windows = arr.windows(7)
+  assert_eq!(windows.length(), 3)
+  inspect!(windows[0], content="[1, 2, 3, 4, 5, 6, 7]")
+  inspect!(windows[1], content="[2, 3, 4, 5, 6, 7, 8]")
+  inspect!(windows[2], content="[3, 4, 5, 6, 7, 8, 9]")
+}
+
 ///|
 test "array_get_out_of_bounds" {
   let arr = [1, 2, 3]

builtin/builtin.mbti

@@ -124,6 +124,7 @@ impl Array {
   unsafe_blit_fixed[A](Self[A], Int, FixedArray[A], Int, Int) -> Unit
   unsafe_get[T](Self[T], Int) -> T
   unsafe_pop[T](Self[T]) -> T
+  windows[T](Self[T], Int) -> Self[Self[T]]
 }
 impl[T] Add for Array[T]
 impl[T : Compare] Compare for Array[T]