refactor(pr-x1): array_window → array_windows (plural, std convention)

Renames the module + functions to match std's plural iterator-type
convention (slice::ArrayWindows / slice::ArrayChunks). Singular
`array_window` returning multiple windows was confusing.

  src/hpc/array_window.rs  → src/hpc/array_windows.rs
  pub fn array_window      → pub fn array_windows
  pub fn array_window_checked → pub fn array_windows_checked

Module doc now explicitly calls out the semantic difference from
std::slice::ArrayWindows: ours is **non-overlapping** (matches
slice::as_chunks / ArrayChunks), std's is overlapping. The plural
name follows std's iterator convention; the non-overlapping
semantics is what SIMD-staged inner loops actually need (each lane
register load advances by N, not by 1).

src/hpc/mod.rs and src/simd.rs re-exports updated.

Author: claude

src/hpc/array_window.rs src/hpc/array_windows.rssrc/hpc/array_window.rs renamed to src/hpc/array_windows.rs

@@ -8,24 +8,24 @@
 //!
 //! # Layering
 //!
-//! Lives in `hpc::array_window`; the `crate::simd::*` re-export lands in the
+//! Lives in `hpc::array_windows`; the `crate::simd::*` re-export lands in the
 //! PR-X1 re-export sweep (see `.claude/knowledge/pr-x1-design.md` § 4).
-//! Doctests therefore use the canonical `ndarray::hpc::array_window` path
+//! Doctests therefore use the canonical `ndarray::hpc::array_windows` path
 //! until the sweep ships.
 //!
 //! # Design reference
 //!
-//! `.claude/knowledge/pr-x1-design.md` § "3. `array_window`". This module
+//! `.claude/knowledge/pr-x1-design.md` § "3. `array_windows`". This module
 //! ships the **iterator-shape** variant (whole-buffer walk yielding all
 //! const-size windows). The design doc sketches a singular-window form
-//! (`array_window(slice, offset) -> &[T; N]`); the maintainer-blessed final
+//! (`array_windows(slice, offset) -> &[T; N]`); the maintainer-blessed final
 //! shape is the iterator form here, which composes directly with SIMD-staged
 //! consumer loops and avoids per-call panic surface in tight inner loops.
 
 /// Walk `data` as a sequence of non-overlapping const-size windows.
 ///
 /// Returns an iterator over `&[T; N]` references into `data`. The tail
-/// (`data.len() % N` items) is discarded; use [`array_window_checked`] to
+/// (`data.len() % N` items) is discarded; use [`array_windows_checked`] to
 /// fail-fast when the length is not a multiple of `N`.
 ///
 /// Zero-cost: this is a thin wrapper around [`slice::as_chunks`] that pins
@@ -34,9 +34,9 @@
 /// # Examples
 ///
 /// ```
-/// use ndarray::hpc::array_window::array_window;
+/// use ndarray::hpc::array_windows::array_windows;
 /// let data: Vec<u8> = (0..16).collect();
-/// let windows: Vec<&[u8; 4]> = array_window::<u8, 4>(&data).collect();
+/// let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
 /// assert_eq!(windows.len(), 4);
 /// assert_eq!(windows[0], &[0, 1, 2, 3]);
 /// assert_eq!(windows[3], &[12, 13, 14, 15]);
@@ -45,43 +45,43 @@
 /// # Examples — tail discarded
 ///
 /// ```
-/// use ndarray::hpc::array_window::array_window;
+/// use ndarray::hpc::array_windows::array_windows;
 /// let data: Vec<u8> = (0..7).collect();
-/// let windows: Vec<&[u8; 4]> = array_window::<u8, 4>(&data).collect();
+/// let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
 /// // 7 / 4 = 1 window; the trailing 3 items are dropped.
 /// assert_eq!(windows.len(), 1);
 /// ```
 #[inline]
-pub fn array_window<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
+pub fn array_windows<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
     data.as_chunks::<N>().0.iter()
 }
 
 /// Walk `data` as `&[T; N]` windows, returning `Err(())` if `data.len()`
 /// is not a multiple of `N`.
 ///
-/// This is the strict variant of [`array_window`]: the consumer asserts up
+/// This is the strict variant of [`array_windows`]: the consumer asserts up
 /// front that the buffer is lane-aligned and the caller wants the error
 /// surfaced rather than silently truncating.
 ///
 /// # Examples
 ///
 /// ```
-/// use ndarray::hpc::array_window::array_window_checked;
+/// use ndarray::hpc::array_windows::array_windows_checked;
 /// let data: Vec<u8> = (0..16).collect();
-/// let it = array_window_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+/// let it = array_windows_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
 /// assert_eq!(it.count(), 4);
 ///
 /// let bad: Vec<u8> = (0..7).collect();
-/// assert!(array_window_checked::<u8, 4>(&bad).is_err());
+/// assert!(array_windows_checked::<u8, 4>(&bad).is_err());
 /// ```
 #[inline]
-pub fn array_window_checked<T, const N: usize>(
+pub fn array_windows_checked<T, const N: usize>(
     data: &[T],
 ) -> Result<impl Iterator<Item = &[T; N]> + '_, ()> {
     if data.len() % N != 0 {
         return Err(());
     }
-    Ok(array_window::<T, N>(data))
+    Ok(array_windows::<T, N>(data))
 }
 
 // ============================================================================
@@ -94,46 +94,46 @@ mod tests {
 
     /// 16-element buffer yields four 4-wide windows.
     #[test]
-    fn array_window_4_over_16() {
+    fn array_windows_4_over_16() {
         let data: Vec<u8> = (0u8..16).collect();
-        let windows: Vec<&[u8; 4]> = array_window::<u8, 4>(&data).collect();
+        let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
         assert_eq!(windows.len(), 4);
         assert_eq!(windows[0], &[0, 1, 2, 3]);
         assert_eq!(windows[1], &[4, 5, 6, 7]);
         assert_eq!(windows[2], &[8, 9, 10, 11]);
         assert_eq!(windows[3], &[12, 13, 14, 15]);
     }
 
-    /// Tail items are silently discarded by `array_window`.
+    /// Tail items are silently discarded by `array_windows`.
     #[test]
-    fn array_window_drops_tail() {
+    fn array_windows_drops_tail() {
         let data: Vec<u8> = (0u8..7).collect();
-        let windows: Vec<&[u8; 4]> = array_window::<u8, 4>(&data).collect();
+        let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
         assert_eq!(windows.len(), 1);
         assert_eq!(windows[0], &[0, 1, 2, 3]);
     }
 
     /// Mismatched length surfaces as Err in the checked variant.
     #[test]
-    fn array_window_checked_rejects_mismatch() {
-        assert!(array_window_checked::<u8, 4>(&[0u8; 7]).is_err());
-        assert!(array_window_checked::<u8, 4>(&[0u8; 5]).is_err());
-        assert!(array_window_checked::<u8, 4>(&[0u8; 1]).is_err());
+    fn array_windows_checked_rejects_mismatch() {
+        assert!(array_windows_checked::<u8, 4>(&[0u8; 7]).is_err());
+        assert!(array_windows_checked::<u8, 4>(&[0u8; 5]).is_err());
+        assert!(array_windows_checked::<u8, 4>(&[0u8; 1]).is_err());
     }
 
     /// Aligned length succeeds in the checked variant.
     #[test]
-    fn array_window_checked_accepts_aligned() {
+    fn array_windows_checked_accepts_aligned() {
         let data = [0u8; 16];
-        let it = array_window_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+        let it = array_windows_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
         assert_eq!(it.count(), 4);
     }
 
     /// Empty buffer yields zero windows (not an error in either variant).
     #[test]
-    fn array_window_empty_buffer() {
-        assert_eq!(array_window::<u8, 4>(&[]).count(), 0);
-        let it = array_window_checked::<u8, 4>(&[]).expect("0 % 4 == 0, should be Ok");
+    fn array_windows_empty_buffer() {
+        assert_eq!(array_windows::<u8, 4>(&[]).count(), 0);
+        let it = array_windows_checked::<u8, 4>(&[]).expect("0 % 4 == 0, should be Ok");
         assert_eq!(it.count(), 0);
     }
 }

src/hpc/mod.rs

@@ -42,7 +42,7 @@ pub mod fingerprint;
 // PR-X1 — multi-lane typed column substrate + const-size array windows.
 // Re-exported from crate::simd::* per the W1a consumer contract.
 pub mod column;
-pub mod array_window;
+pub mod array_windows;
 #[allow(missing_docs)]
 pub mod plane;
 #[allow(missing_docs)]

src/simd.rs

@@ -134,12 +134,12 @@ fn tier() -> Tier {
 // function uses as_chunks::<16>() + as_chunks::<8>() for SIMD widths.
 
 // ============================================================================
-// Preferred SIMD lane widths — compile-time constants for array_windows
+// Preferred SIMD lane widths — compile-time constants for array_windowss
 // ============================================================================
 //
-// Consumer code uses these to select array_windows size at compile time:
+// Consumer code uses these to select array_windowss size at compile time:
 //
-//   for window in data.array_windows::<{crate::simd::PREFERRED_F64_LANES}>() {
+//   for window in data.array_windowss::<{crate::simd::PREFERRED_F64_LANES}>() {
 //       let v = F64x8::from_array(*window);   // AVX-512: native 8-wide
 //       // or
 //       let v = F64x4::from_array(*window);   // AVX2: native 4-wide
@@ -1723,7 +1723,7 @@ pub use crate::hpc::fingerprint::{
 // through `crate::simd::*`; without these re-exports the cognitive-shader
 // stack reaches for `crate::hpc::column::*` directly, breaking the contract.
 pub use crate::hpc::column::MultiLaneColumn;
-pub use crate::hpc::array_window::{array_window, array_window_checked};
+pub use crate::hpc::array_windows::{array_windows, array_windows_checked};
 
 pub use crate::hpc::quantized::{
     dequantize_i2_to_f32, dequantize_i4_to_f32, dequantize_i8_to_f32, quantize_f32_to_i2, quantize_f32_to_i4,