Add Array::windows

Author: MINGtoMING

builtin/array.mbt

@@ -1639,6 +1639,45 @@ pub fn Array::chunk_by[T](
   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 Array::windows[T](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

@@ -494,6 +494,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

@@ -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[ArrayView[T]]
 }
 impl[T] Add for Array[T]
 impl[T : Compare] Compare for Array[T]