docs/tests: fix rustdoc links and appease clippy strict lints (#1576)

Tighten linting; fix rustdoc warnings across feature gates

I continued using stricter linting and found several odd cases in tests
and
examples, along with rustdoc warnings triggered by feature-gated items.

This commit cleans up those warnings by:
- adjusting tests to avoid clippy false positives under -D warnings
- removing unused generics and ambiguous empty vec initializers
- fixing rustdoc links via feature-gated doc attributes rather than
  linking to non-exported items

All tests are still passing.

Clippy still warns about the use of `1..-1` as an empty range; this
appears
intentional in ndarray slicing semantics, so I’ve left it unchanged for
now.

Please review the rustdoc changes that rely on feature-gated
documentation.

Author: RPG-Alex

src/doc/crate_feature_flags.rs

@@ -14,9 +14,14 @@
 //! ## `serde`
 //!   - Enables serialization support for serde 1.x
 //!
-//! ## `rayon`
-//!   - Enables parallel iterators, parallelized methods, the [`parallel`] module and [`par_azip!`].
-//!   - Implies std
+#![cfg_attr(
+    not(feature = "rayon"),
+    doc = "//! ## `rayon`\n//!   - Enables parallel iterators, parallelized methods, and the `par_azip!` macro.\n//!   - Implies std\n"
+)]
+#![cfg_attr(
+    feature = "rayon",
+    doc = "//! ## `rayon`\n//!   - Enables parallel iterators, parallelized methods, the [`crate::parallel`] module and [`crate::parallel::par_azip`].\n//!   - Implies std\n"
+)]
 //!
 //! ## `approx`
 //!   - Enables implementations of traits of the [`approx`] crate.
@@ -28,8 +33,3 @@
 //!
 //! ## `matrixmultiply-threading`
 //!   - Enable the ``threading`` feature in the matrixmultiply package
-//!
-//! [`parallel`]: crate::parallel
-
-#[cfg(doc)]
-use crate::parallel::par_azip;

src/lib.rs

@@ -84,11 +84,18 @@
 //! ## Crate Feature Flags
 //!
 //! The following crate feature flags are available. They are configured in your
-//! `Cargo.toml`. See [`doc::crate_feature_flags`] for more information.
+//! `Cargo.toml`. See [`crate::doc::crate_feature_flags`] for more information.
 //!
 //! - `std`: Rust standard library-using functionality (enabled by default)
 //! - `serde`: serialization support for serde 1.x
-//! - `rayon`: Parallel iterators, parallelized methods, the [`parallel`] module and [`par_azip!`].
+#![cfg_attr(
+    not(feature = "rayon"),
+    doc = "//! - `rayon`: Parallel iterators, parallelized methods, and the `par_azip!` macro."
+)]
+#![cfg_attr(
+    feature = "rayon",
+    doc = "//! - `rayon`: Parallel iterators, parallelized methods, the [`parallel`] module and [`par_azip!`]."
+)]
 //! - `approx` Implementations of traits from the [`approx`] crate.
 //! - `blas`: transparent BLAS support for matrix multiplication, needs configuration.
 //! - `matrixmultiply-threading`: Use threading from `matrixmultiply`.
@@ -129,7 +136,7 @@ extern crate std;
 #[cfg(feature = "blas")]
 extern crate cblas_sys;
 
-#[cfg(docsrs)]
+#[cfg(any(doc, docsrs))]
 pub mod doc;
 
 use alloc::fmt::Debug;

src/linalg/impl_linalg.rs

@@ -968,6 +968,63 @@ where
     is_blas_2d(a._dim(), a._strides(), BlasOrder::F)
 }
 
+/// Dot product for dynamic-dimensional arrays (`ArrayD`).
+///
+/// For one-dimensional arrays, computes the vector dot product, which is the sum
+/// of the elementwise products (no conjugation of complex operands).
+/// Both arrays must have the same length.
+///
+/// For two-dimensional arrays, performs matrix multiplication. The array shapes
+/// must be compatible in the following ways:
+/// - If `self` is *M* × *N*, then `rhs` must be *N* × *K* for matrix-matrix multiplication
+/// - If `self` is *M* × *N* and `rhs` is *N*, returns a vector of length *M*
+/// - If `self` is *M* and `rhs` is *M* × *N*, returns a vector of length *N*
+/// - If both arrays are one-dimensional of length *N*, returns a scalar
+///
+/// **Panics** if:
+/// - The arrays have dimensions other than 1 or 2
+/// - The array shapes are incompatible for the operation
+/// - For vector dot product: the vectors have different lengths
+impl<A> Dot<ArrayRef<A, IxDyn>> for ArrayRef<A, IxDyn>
+where A: LinalgScalar
+{
+    type Output = Array<A, IxDyn>;
+
+    fn dot(&self, rhs: &ArrayRef<A, IxDyn>) -> Self::Output
+    {
+        match (self.ndim(), rhs.ndim()) {
+            (1, 1) => {
+                let a = self.view().into_dimensionality::<Ix1>().unwrap();
+                let b = rhs.view().into_dimensionality::<Ix1>().unwrap();
+                let result = a.dot(&b);
+                ArrayD::from_elem(vec![], result)
+            }
+            (2, 2) => {
+                // Matrix-matrix multiplication
+                let a = self.view().into_dimensionality::<Ix2>().unwrap();
+                let b = rhs.view().into_dimensionality::<Ix2>().unwrap();
+                let result = a.dot(&b);
+                result.into_dimensionality::<IxDyn>().unwrap()
+            }
+            (2, 1) => {
+                // Matrix-vector multiplication
+                let a = self.view().into_dimensionality::<Ix2>().unwrap();
+                let b = rhs.view().into_dimensionality::<Ix1>().unwrap();
+                let result = a.dot(&b);
+                result.into_dimensionality::<IxDyn>().unwrap()
+            }
+            (1, 2) => {
+                // Vector-matrix multiplication
+                let a = self.view().into_dimensionality::<Ix1>().unwrap();
+                let b = rhs.view().into_dimensionality::<Ix2>().unwrap();
+                let result = a.dot(&b);
+                result.into_dimensionality::<IxDyn>().unwrap()
+            }
+            _ => panic!("Dot product for ArrayD is only supported for 1D and 2D arrays"),
+        }
+    }
+}
+
 #[cfg(test)]
 #[cfg(feature = "blas")]
 mod blas_tests
@@ -1083,60 +1140,3 @@ mod blas_tests
         }
     }
 }
-
-/// Dot product for dynamic-dimensional arrays (`ArrayD`).
-///
-/// For one-dimensional arrays, computes the vector dot product, which is the sum
-/// of the elementwise products (no conjugation of complex operands).
-/// Both arrays must have the same length.
-///
-/// For two-dimensional arrays, performs matrix multiplication. The array shapes
-/// must be compatible in the following ways:
-/// - If `self` is *M* × *N*, then `rhs` must be *N* × *K* for matrix-matrix multiplication
-/// - If `self` is *M* × *N* and `rhs` is *N*, returns a vector of length *M*
-/// - If `self` is *M* and `rhs` is *M* × *N*, returns a vector of length *N*
-/// - If both arrays are one-dimensional of length *N*, returns a scalar
-///
-/// **Panics** if:
-/// - The arrays have dimensions other than 1 or 2
-/// - The array shapes are incompatible for the operation
-/// - For vector dot product: the vectors have different lengths
-impl<A> Dot<ArrayRef<A, IxDyn>> for ArrayRef<A, IxDyn>
-where A: LinalgScalar
-{
-    type Output = Array<A, IxDyn>;
-
-    fn dot(&self, rhs: &ArrayRef<A, IxDyn>) -> Self::Output
-    {
-        match (self.ndim(), rhs.ndim()) {
-            (1, 1) => {
-                let a = self.view().into_dimensionality::<Ix1>().unwrap();
-                let b = rhs.view().into_dimensionality::<Ix1>().unwrap();
-                let result = a.dot(&b);
-                ArrayD::from_elem(vec![], result)
-            }
-            (2, 2) => {
-                // Matrix-matrix multiplication
-                let a = self.view().into_dimensionality::<Ix2>().unwrap();
-                let b = rhs.view().into_dimensionality::<Ix2>().unwrap();
-                let result = a.dot(&b);
-                result.into_dimensionality::<IxDyn>().unwrap()
-            }
-            (2, 1) => {
-                // Matrix-vector multiplication
-                let a = self.view().into_dimensionality::<Ix2>().unwrap();
-                let b = rhs.view().into_dimensionality::<Ix1>().unwrap();
-                let result = a.dot(&b);
-                result.into_dimensionality::<IxDyn>().unwrap()
-            }
-            (1, 2) => {
-                // Vector-matrix multiplication
-                let a = self.view().into_dimensionality::<Ix1>().unwrap();
-                let b = rhs.view().into_dimensionality::<Ix2>().unwrap();
-                let result = a.dot(&b);
-                result.into_dimensionality::<IxDyn>().unwrap()
-            }
-            _ => panic!("Dot product for ArrayD is only supported for 1D and 2D arrays"),
-        }
-    }
-}

src/zip/mod.rs

@@ -424,6 +424,7 @@ where D: Dimension
     }
 
     #[cfg(feature = "rayon")]
+    #[allow(dead_code)]
     pub(crate) fn uninitialized_for_current_layout<T>(&self) -> Array<MaybeUninit<T>, D>
     {
         let is_f = self.prefer_f();

tests/array.rs

@@ -4,6 +4,7 @@
 )]
 
 use approx::assert_relative_eq;
+use core::panic;
 use defmac::defmac;
 #[allow(deprecated)]
 use itertools::{zip, Itertools};
@@ -1005,7 +1006,7 @@ fn iter_size_hint()
 fn zero_axes()
 {
     let mut a = arr1::<f32>(&[]);
-    if let Some(_) = a.iter().next() {
+    if a.iter().next().is_some() {
         panic!();
     }
     a.map(|_| panic!());
@@ -2080,7 +2081,7 @@ fn test_contiguous()
     assert!(c.as_slice_memory_order().is_some());
     let v = c.slice(s![.., 0..1, ..]);
     assert!(!v.is_standard_layout());
-    assert!(!v.as_slice_memory_order().is_some());
+    assert!(v.as_slice_memory_order().is_none());
 
     let v = c.slice(s![1..2, .., ..]);
     assert!(v.is_standard_layout());

tests/iterators.rs

@@ -195,7 +195,7 @@ fn inner_iter_corner_cases()
     assert_equal(a0.rows(), vec![aview1(&[0])]);
 
     let a2 = ArcArray::<i32, _>::zeros((0, 3));
-    assert_equal(a2.rows(), vec![aview1(&[]); 0]);
+    assert_equal(a2.rows(), Vec::<ArrayView1<'_, i32>>::new());
 
     let a2 = ArcArray::<i32, _>::zeros((3, 0));
     assert_equal(a2.rows(), vec![aview1(&[]); 3]);
@@ -359,11 +359,13 @@ fn axis_iter_zip_partially_consumed_discontiguous()
     }
 }
 
+use ndarray::ArrayView1;
+
 #[test]
 fn outer_iter_corner_cases()
 {
     let a2 = ArcArray::<i32, _>::zeros((0, 3));
-    assert_equal(a2.outer_iter(), vec![aview1(&[]); 0]);
+    assert_equal(a2.outer_iter(), Vec::<ArrayView1<'_, i32>>::new());
 
     let a2 = ArcArray::<i32, _>::zeros((3, 0));
     assert_equal(a2.outer_iter(), vec![aview1(&[]); 3]);

tests/numeric.rs

@@ -175,7 +175,7 @@ fn var_too_large_ddof()
 fn var_nan_ddof()
 {
     let a = Array2::<f64>::zeros((2, 3));
-    let v = a.var(std::f64::NAN);
+    let v = a.var(f64::NAN);
     assert!(v.is_nan());
 }
 

tests/oper.rs

@@ -19,20 +19,20 @@ fn test_oper(op: &str, a: &[f32], b: &[f32], c: &[f32])
     let aa = CowArray::from(arr1(a));
     let bb = CowArray::from(arr1(b));
     let cc = CowArray::from(arr1(c));
-    test_oper_arr::<f32, _>(op, aa.clone(), bb.clone(), cc.clone());
+    test_oper_arr(op, aa.clone(), bb.clone(), cc.clone());
     let dim = (2, 2);
     let aa = aa.to_shape(dim).unwrap();
     let bb = bb.to_shape(dim).unwrap();
     let cc = cc.to_shape(dim).unwrap();
-    test_oper_arr::<f32, _>(op, aa.clone(), bb.clone(), cc.clone());
+    test_oper_arr(op, aa.clone(), bb.clone(), cc.clone());
     let dim = (1, 2, 1, 2);
     let aa = aa.to_shape(dim).unwrap();
     let bb = bb.to_shape(dim).unwrap();
     let cc = cc.to_shape(dim).unwrap();
-    test_oper_arr::<f32, _>(op, aa.clone(), bb.clone(), cc.clone());
+    test_oper_arr(op, aa.clone(), bb.clone(), cc.clone());
 }
 
-fn test_oper_arr<A, D>(op: &str, mut aa: CowArray<f32, D>, bb: CowArray<f32, D>, cc: CowArray<f32, D>)
+fn test_oper_arr<D>(op: &str, mut aa: CowArray<f32, D>, bb: CowArray<f32, D>, cc: CowArray<f32, D>)
 where D: Dimension
 {
     match op {