fix(pr-x1): rename array_windows → array_chunks (collision with std)

The plural rename in 2a2dfbf collided with the std slice method
`array_windows` already referenced in `src/simd.rs` (lines 137-142,
the `// Preferred SIMD lane widths` block uses
`data.array_windows::<N>()` in its examples).

Renamed to `array_chunks`, which:
- matches the actual non-overlapping semantics of the helper
- aligns with std's `slice::array_chunks` / `slice::as_chunks` naming
- avoids any collision with std's `array_windows` (overlapping) that
  the SIMD layer will use once it stabilises

Also fixes a sed double-substitution bug from 2a2dfbf that left
`array_windowss` (double-s) in three places in `src/simd.rs` —
those are now back to the correct `array_windows` reference to
std's method.

Module doc now contrasts our non-overlapping `array_chunks` against
std's overlapping `array_windows` so the naming choice is documented
in-tree.

Author: claude

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

@@ -1,45 +1,46 @@
-//! Const-size sliding-window helpers over `&[T]` (PR-X1).
+//! Const-size non-overlapping chunk helpers over `&[T]` (PR-X1).
 //!
 //! Centralises the `&[T] → impl Iterator<Item = &[T; N]>` pattern that
 //! SIMD-staged consumers use to walk a buffer N lanes at a time. Without
 //! this helper, each consumer either calls `slice::as_chunks::<N>` directly
 //! (fine but undiscoverable) or rolls a raw slice index without the
 //! compile-time bounds check.
 //!
-//! # Semantics — non-overlapping (NOT std `array_windows`)
+//! # Naming — `array_chunks`, not `array_windows`
 //!
-//! Despite the plural name, this is the **non-overlapping** chunk variant —
-//! consecutive windows do not share elements. The name follows std's
-//! plural iterator-type convention ([`std::slice::ArrayWindows`]), but the
-//! semantics match [`std::slice::ArrayChunks`] / `slice::as_chunks`.
+//! `std::slice::array_windows::<N>()` (nightly) already exists and is the
+//! **overlapping** iterator — `crate::simd::*` re-uses that name for the
+//! std method once it stabilises (see the `// Preferred SIMD lane widths`
+//! block at the top of `src/simd.rs`, which uses `data.array_windows::<N>()`
+//! in its examples).
 //!
-//! For an 8-element input walked at `N = 4`:
-//! - `array_windows` (this module): yields `[0..4]`, `[4..8]` — **2 windows**.
+//! This helper is the **non-overlapping** variant, matching
+//! [`std::slice::ArrayChunks`] / stable `slice::as_chunks`. For an 8-element
+//! input at `N = 4`:
+//! - `array_chunks` (this module): yields `[0..4]`, `[4..8]` — 2 windows.
 //! - `std::slice::array_windows` (overlapping): would yield 5 windows.
 //!
 //! Non-overlapping is the correct shape for SIMD-staged inner loops where
 //! each lane-register load consumes its N elements before advancing by N.
 //!
 //! # Layering
 //!
-//! Lives in `hpc::array_windows`, re-exported from `crate::simd::*` per the
+//! Lives in `hpc::array_chunks`, re-exported from `crate::simd::*` per the
 //! W1a consumer contract at
 //! `.claude/knowledge/vertical-simd-consumer-contract.md`.
 //!
 //! # Design reference
 //!
-//! `.claude/knowledge/pr-x1-design.md` § "3. `array_window`". This module
-//! ships the **iterator-shape** variant (whole-buffer walk yielding all
-//! const-size windows); the design doc's singular-window sketch
-//! (`array_window(slice, offset) -> &[T; N]`) was superseded by the
-//! iterator form here, which composes directly with SIMD-staged consumer
-//! loops and avoids per-call panic surface in tight inner loops. The name
-//! was pluralised to match the std iterator-type convention.
+//! `.claude/knowledge/pr-x1-design.md` § "3. `array_window`". The design
+//! doc's singular-window sketch (`array_window(slice, offset) -> &[T; N]`)
+//! was superseded by the iterator form here. The name landed as
+//! `array_chunks` to avoid collision with std's `array_windows` (overlapping)
+//! already referenced in the SIMD layer.
 
 /// 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_windows_checked`] to
+/// (`data.len() % N` items) is discarded; use [`array_chunks_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
@@ -48,9 +49,9 @@
 /// # Examples
 ///
 /// ```
-/// use ndarray::hpc::array_windows::array_windows;
+/// use ndarray::hpc::array_chunks::array_chunks;
 /// let data: Vec<u8> = (0..16).collect();
-/// let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
+/// let windows: Vec<&[u8; 4]> = array_chunks::<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]);
@@ -59,43 +60,43 @@
 /// # Examples — tail discarded
 ///
 /// ```
-/// use ndarray::hpc::array_windows::array_windows;
+/// use ndarray::hpc::array_chunks::array_chunks;
 /// let data: Vec<u8> = (0..7).collect();
-/// let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
+/// let windows: Vec<&[u8; 4]> = array_chunks::<u8, 4>(&data).collect();
 /// // 7 / 4 = 1 window; the trailing 3 items are dropped.
 /// assert_eq!(windows.len(), 1);
 /// ```
 #[inline]
-pub fn array_windows<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
+pub fn array_chunks<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_windows`]: the consumer asserts up
+/// This is the strict variant of [`array_chunks`]: 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_windows::array_windows_checked;
+/// use ndarray::hpc::array_chunks::array_chunks_checked;
 /// let data: Vec<u8> = (0..16).collect();
-/// let it = array_windows_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+/// let it = array_chunks_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_windows_checked::<u8, 4>(&bad).is_err());
+/// assert!(array_chunks_checked::<u8, 4>(&bad).is_err());
 /// ```
 #[inline]
-pub fn array_windows_checked<T, const N: usize>(
+pub fn array_chunks_checked<T, const N: usize>(
     data: &[T],
 ) -> Result<impl Iterator<Item = &[T; N]> + '_, ()> {
     if data.len() % N != 0 {
         return Err(());
     }
-    Ok(array_windows::<T, N>(data))
+    Ok(array_chunks::<T, N>(data))
 }
 
 // ============================================================================
@@ -108,46 +109,46 @@ mod tests {
 
     /// 16-element buffer yields four 4-wide windows.
     #[test]
-    fn array_windows_4_over_16() {
+    fn array_chunks_4_over_16() {
         let data: Vec<u8> = (0u8..16).collect();
-        let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
+        let windows: Vec<&[u8; 4]> = array_chunks::<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_windows`.
+    /// Tail items are silently discarded by `array_chunks`.
     #[test]
-    fn array_windows_drops_tail() {
+    fn array_chunks_drops_tail() {
         let data: Vec<u8> = (0u8..7).collect();
-        let windows: Vec<&[u8; 4]> = array_windows::<u8, 4>(&data).collect();
+        let windows: Vec<&[u8; 4]> = array_chunks::<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_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());
+    fn array_chunks_checked_rejects_mismatch() {
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 7]).is_err());
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 5]).is_err());
+        assert!(array_chunks_checked::<u8, 4>(&[0u8; 1]).is_err());
     }
 
     /// Aligned length succeeds in the checked variant.
     #[test]
-    fn array_windows_checked_accepts_aligned() {
+    fn array_chunks_checked_accepts_aligned() {
         let data = [0u8; 16];
-        let it = array_windows_checked::<u8, 4>(&data).expect("16 is a multiple of 4");
+        let it = array_chunks_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_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");
+    fn array_chunks_empty_buffer() {
+        assert_eq!(array_chunks::<u8, 4>(&[]).count(), 0);
+        let it = array_chunks_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_windows;
+pub mod array_chunks;
 #[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_windowss
+// Preferred SIMD lane widths — compile-time constants for array_windows
 // ============================================================================
 //
-// Consumer code uses these to select array_windowss size at compile time:
+// Consumer code uses these to select array_windows size at compile time:
 //
-//   for window in data.array_windowss::<{crate::simd::PREFERRED_F64_LANES}>() {
+//   for window in data.array_windows::<{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_windows::{array_windows, array_windows_checked};
+pub use crate::hpc::array_chunks::{array_chunks, array_chunks_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,