Add Array::windows

Author: Zhenming-Lin

builtin/array.mbt

@@ -1637,6 +1637,45 @@ pub fn[T] Array::chunk_by(
   chunks
 }
 
+///|
+/// Generates overlapping subslices (sliding windows) of the specified size.
+///
+/// Parameters:
+///
+/// * `array` : The array to be processed with sliding windows.
+/// * `size` : The window length. Must be a positive integer.
+///
+/// Returns an array of slices, where each inner slice is a contiguous subslice
+/// of the original array. Windows are produced with a step size of 1. If the
+/// original array's length is less than the specified window size, the result
+/// will be 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[T] Array::windows(self : Array[T], size : Int) -> Array[ArrayView[T]] {
+  let len = self.length() - size + 1
+  if len < 1 {
+    return []
+  }
+  let windows = Array::new(capacity=len)
+  for i in 0..<len {
+    windows.push(self[i:i + size])
+  }
+  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

@@ -498,6 +498,17 @@ test "chunks_by" {
   )
 }
 
+///|
+test "array_windows" {
+  let arr = [1, 2, 3, 4, 5, 6]
+  let windows = arr.windows(11)
+  inspect!(windows, content="[]")
+  let windows = arr.windows(5)
+  inspect!(windows, content="[[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]]")
+  let windows = arr.windows(1)
+  inspect!(windows, content="[[1], [2], [3], [4], [5], [6]]")
+}
+
 ///|
 test "array_get_out_of_bounds" {
   let arr = [1, 2, 3]

builtin/builtin.mbti

@@ -122,6 +122,7 @@ fn[A] Array::unsafe_blit_fixed(Self[A], Int, FixedArray[A], Int, Int) -> Unit
 fn[T] Array::unsafe_get(Self[T], Int) -> T
 fn[T] Array::unsafe_pop(Self[T]) -> T
 fn[A] Array::unsafe_pop_back(Self[A]) -> Unit
+fn[T] Array::windows(Self[T], Int) -> Self[ArrayView[T]]
 impl[T] Add for Array[T]
 impl[T : Compare] Compare for Array[T]
 impl[T] Default for Array[T]