Address clippy warnings

Author: kngwyu

src/array.rs

@@ -17,13 +17,11 @@ use crate::npyffi::npy_intp;
 /// **you cannot use some destructive methods like `resize`.**
 /// # Example
 /// ```
-/// # fn main() {
 /// use numpy::{PyArray, IntoPyArray};
 /// let gil = pyo3::Python::acquire_gil();
 /// let py_array = vec![1, 2, 3].into_pyarray(gil.python());
 /// assert_eq!(py_array.as_slice().unwrap(), &[1, 2, 3]);
 /// assert!(py_array.resize(100).is_err()); // You can't resize owned-by-rust array.
-/// # }
 /// ```
 pub trait IntoPyArray {
     type Item: TypeNum;
@@ -132,7 +130,7 @@ where
                 let array = PyArray::<A, _>::new_(py, dim, strides.as_ptr(), 0);
                 let data_ptr = array.data();
                 for (i, item) in self.iter().enumerate() {
-                    data_ptr.offset(i as isize).write(*item);
+                    data_ptr.add(i).write(*item);
                 }
                 array
             }
@@ -166,7 +164,7 @@ where
 {
     fn npy_strides(&self) -> NpyStrides {
         NpyStrides::new(
-            self.strides().into_iter().map(|&x| x as npyffi::npy_intp),
+            self.strides().iter().map(|&x| x as npyffi::npy_intp),
             mem::size_of::<A>(),
         )
     }
@@ -199,7 +197,7 @@ impl NpyStrides {
         Self::new(
             dim.default_strides()
                 .slice()
-                .into_iter()
+                .iter()
                 .map(|&x| x as npyffi::npy_intp),
             type_size,
         )
@@ -266,7 +264,7 @@ impl<D: IntoDimension> NpyIndex for D {
         if indices.len() != dims.len() {
             return None;
         }
-        if indices.into_iter().zip(dims).any(|(i, d)| i >= d) {
+        if indices.iter().zip(dims).any(|(i, d)| i >= d) {
             return None;
         }
         Some(get_unchecked_impl(

src/convert.rs

@@ -64,20 +64,20 @@ pub enum ErrorKind {
 }
 
 impl ErrorKind {
-    pub(crate) fn to_rust(
-        from_t: i32,
-        from_d: usize,
-        to_t: NpyDataType,
-        to_d: Option<usize>,
+    pub(crate) fn py_to_rust(
+        from_type: i32,
+        from_dim: usize,
+        to_type: NpyDataType,
+        to_dim: Option<usize>,
     ) -> Self {
         ErrorKind::PyToRust {
             from: ArrayDim {
-                dim: Some(from_d),
-                dtype: NpyDataType::from_i32(from_t),
+                dim: Some(from_dim),
+                dtype: NpyDataType::from_i32(from_type),
             },
             to: ArrayDim {
-                dim: to_d,
-                dtype: to_t,
+                dim: to_dim,
+                dtype: to_type,
             },
         }
     }

src/error.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::missing_safety_doc, clippy::too_many_arguments)] // FIXME
+
 //! `rust-numpy` provides Rust interfaces for [NumPy C APIs](https://numpy.org/doc/stable/reference/c-api),
 //! especially for [ndarray](https://numpy.org/doc/stable/reference/arrays.ndarray.html) class.
 //!

src/lib.rs

@@ -18,16 +18,14 @@ const CAPSULE_NAME: &str = "_ARRAY_API";
 ///
 /// # Example
 /// ```
-/// # fn main() {
 /// use numpy::{PyArray, npyffi::types::NPY_SORTKIND, PY_ARRAY_API};
 /// use pyo3::Python;
 /// let gil = Python::acquire_gil();
 /// let array = PyArray::from_slice(gil.python(), &[3, 2, 4]);
 /// unsafe {
 ///     PY_ARRAY_API.PyArray_Sort(array.as_array_ptr(), 0, NPY_SORTKIND::NPY_QUICKSORT);
 /// }
-/// assert_eq!(array.as_slice().unwrap(), &[2, 3, 4])
-/// # }
+/// assert_eq!(array.as_slice().unwrap(), &[2, 3, 4]);
 /// ```
 pub static PY_ARRAY_API: PyArrayAPI = PyArrayAPI::new();
 

src/npyffi/array.rs

@@ -116,7 +116,7 @@ fn from_vec2() {
     let gil = pyo3::Python::acquire_gil();
     let pyarray = PyArray::from_vec2(gil.python(), &vec2).unwrap();
     assert_eq!(pyarray.as_array(), array![[1, 2, 3], [1, 2, 3]]);
-    assert!(PyArray::from_vec2(gil.python(), &vec![vec![1], vec![2, 3]]).is_err());
+    assert!(PyArray::from_vec2(gil.python(), &[vec![1], vec![2, 3]]).is_err());
 }
 
 #[test]

tests/array.rs

@@ -17,7 +17,7 @@ fn to_pyarray_array() {
     let gil = pyo3::Python::acquire_gil();
 
     let a = Array3::<f64>::zeros((3, 4, 2));
-    let shape = a.shape().iter().cloned().collect::<Vec<_>>();
+    let shape = a.shape().to_vec();
     let strides = a.strides().iter().map(|d| d * 8).collect::<Vec<_>>();
     println!("a.shape   = {:?}", a.shape());
     println!("a.strides = {:?}", a.strides());
@@ -94,7 +94,7 @@ fn into_pyarray_vec() {
 fn into_pyarray_array() {
     let gil = pyo3::Python::acquire_gil();
     let arr = Array3::<f64>::zeros((3, 4, 2));
-    let shape = arr.shape().iter().cloned().collect::<Vec<_>>();
+    let shape = arr.shape().to_vec();
     let strides = arr.strides().iter().map(|d| d * 8).collect::<Vec<_>>();
     let py_arr = arr.into_pyarray(gil.python());
     assert_eq!(py_arr.shape(), shape.as_slice());