Some Clippy lints (#642)

* some initial clippy fixes

* some clippy lints cleaned

* one more

* more lints

* even more

* more lints

* all clippy lints solved or ignored

* test in travis

* revert from_iter changes

* add temporary allow to from_iter lint

* install clippy in travis

* only run clippy on nightly

* cloned rather than copied

* miscreant line

* collapse non-looping loop

* Derive traits for Axis instead of manual impl

The behavior should be identical.

* Remove manual impls of Send and Sync for IxDynImpl

`Send` and `Sync` are automatically implemented, so manual
implementations aren't necessary.

* Implement Hash for IxDynRepr and IxDynImpl

* Derive Hash for Dim instead of manual impl

This avoids any issues associated with deriving `PartialEq` but
manually implementing `Hash`.

* Simplify remove_axis using copy_from_slice

* Implement TrustedIterator for Cloned

* Clarify docs for TrustedIterator

* Reformat match in slice_collapse

* Remove unnecessary .clone() call

* Reformat values of CORDER and FORDER

* explicit folds

* more minor changes

* replace notes with reference to @jturner314 comment

* more small tweaks

* flup re len & empty

* clippy on beta only since sometimes not available on nightly (e.g. today)

* only attempt clippy install on beta

* srlsy?

* bash precedence

* set aside one lint for the moment

Author: max-sixty

.travis.yml

@@ -13,10 +13,11 @@ matrix:
     - rust: beta
       env:
        - FEATURES='test docs'
+       - CHANNEL='beta'
     - rust: nightly
       env:
        - FEATURES='test docs'
-       - IS_NIGHTLY=1
+       - CHANNEL='nightly'
 env:
   global:
     - HOST=x86_64-unknown-linux-gnu
@@ -30,5 +31,5 @@ before_script:
   - rustup component add rustfmt
 script:
   - |
-      cargo fmt --all -- --check &&
-      ./scripts/all-tests.sh "$FEATURES" "$IS_NIGHTLY"
+    cargo fmt --all -- --check &&
+    ./scripts/all-tests.sh "$FEATURES" "$CHANNEL"

benches/bench1.rs

@@ -1,5 +1,11 @@
 #![feature(test)]
 #![allow(unused_imports)]
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 
 extern crate ndarray;
 extern crate test;
@@ -304,6 +310,7 @@ fn add_2d_zip_cutout(bench: &mut test::Bencher) {
 }
 
 #[bench]
+#[allow(clippy::identity_op)]
 fn add_2d_cutouts_by_4(bench: &mut test::Bencher) {
     let mut a = Array::<i32, _>::zeros((64 * 1, 64 * 1));
     let b = Array::<i32, _>::zeros((64 * 1, 64 * 1));
@@ -316,6 +323,7 @@ fn add_2d_cutouts_by_4(bench: &mut test::Bencher) {
 }
 
 #[bench]
+#[allow(clippy::identity_op)]
 fn add_2d_cutouts_by_16(bench: &mut test::Bencher) {
     let mut a = Array::<i32, _>::zeros((64 * 1, 64 * 1));
     let b = Array::<i32, _>::zeros((64 * 1, 64 * 1));
@@ -328,6 +336,7 @@ fn add_2d_cutouts_by_16(bench: &mut test::Bencher) {
 }
 
 #[bench]
+#[allow(clippy::identity_op)]
 fn add_2d_cutouts_by_32(bench: &mut test::Bencher) {
     let mut a = Array::<i32, _>::zeros((64 * 1, 64 * 1));
     let b = Array::<i32, _>::zeros((64 * 1, 64 * 1));
@@ -580,7 +589,7 @@ fn iadd_scalar_2d_strided_dyn(bench: &mut test::Bencher) {
 fn scaled_add_2d_f32_regular(bench: &mut test::Bencher) {
     let mut av = Array::<f32, _>::zeros((ADD2DSZ, ADD2DSZ));
     let bv = Array::<f32, _>::zeros((ADD2DSZ, ADD2DSZ));
-    let scalar = 3.1415926535;
+    let scalar = std::f32::consts::PI;
     bench.iter(|| {
         av.scaled_add(scalar, &bv);
     });
@@ -650,7 +659,7 @@ fn bench_row_iter(bench: &mut test::Bencher) {
     let a = Array::<f32, _>::zeros((1024, 1024));
     let it = a.row(17);
     bench.iter(|| {
-        for elt in it.clone() {
+        for elt in it {
             black_box(elt);
         }
     })
@@ -661,7 +670,7 @@ fn bench_col_iter(bench: &mut test::Bencher) {
     let a = Array::<f32, _>::zeros((1024, 1024));
     let it = a.column(17);
     bench.iter(|| {
-        for elt in it.clone() {
+        for elt in it {
             black_box(elt);
         }
     })

benches/chunks.rs

@@ -64,6 +64,7 @@ fn chunk2x2_sum_uget1(bench: &mut Bencher) {
 }
 
 #[bench]
+#[allow(clippy::identity_op)]
 fn chunk2x2_sum_get2(bench: &mut Bencher) {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);

benches/construct.rs

@@ -1,5 +1,10 @@
 #![feature(test)]
-
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 extern crate test;
 use test::Bencher;
 

benches/gemv.rs

@@ -1,4 +1,10 @@
 #![feature(test)]
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 
 extern crate test;
 use test::Bencher;

benches/higher-order.rs

@@ -1,5 +1,10 @@
 #![feature(test)]
-
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 extern crate test;
 use test::black_box;
 use test::Bencher;
@@ -67,13 +72,13 @@ fn map_axis_0(bench: &mut Bencher) {
     let a = Array::from_iter(0..MASZ as i32)
         .into_shape([MA, MA])
         .unwrap();
-    bench.iter(|| a.map_axis(Axis(0), |lane| black_box(lane)));
+    bench.iter(|| a.map_axis(Axis(0), black_box));
 }
 
 #[bench]
 fn map_axis_1(bench: &mut Bencher) {
     let a = Array::from_iter(0..MASZ as i32)
         .into_shape([MA, MA])
         .unwrap();
-    bench.iter(|| a.map_axis(Axis(1), |lane| black_box(lane)));
+    bench.iter(|| a.map_axis(Axis(1), black_box));
 }

benches/iter.rs

@@ -1,4 +1,10 @@
 #![feature(test)]
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 
 extern crate rawpointer;
 extern crate test;
@@ -14,15 +20,15 @@ use ndarray::{FoldWhile, Zip};
 #[bench]
 fn iter_sum_2d_regular(bench: &mut Bencher) {
     let a = Array::<i32, _>::zeros((64, 64));
-    bench.iter(|| a.iter().fold(0, |acc, &x| acc + x));
+    bench.iter(|| a.iter().sum::<i32>());
 }
 
 #[bench]
 fn iter_sum_2d_cutout(bench: &mut Bencher) {
     let a = Array::<i32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]);
     let a = av;
-    bench.iter(|| a.iter().fold(0, |acc, &x| acc + x));
+    bench.iter(|| a.iter().sum::<i32>());
 }
 
 #[bench]
@@ -37,37 +43,37 @@ fn iter_all_2d_cutout(bench: &mut Bencher) {
 fn iter_sum_2d_transpose(bench: &mut Bencher) {
     let a = Array::<i32, _>::zeros((66, 66));
     let a = a.t();
-    bench.iter(|| a.iter().fold(0, |acc, &x| acc + x));
+    bench.iter(|| a.iter().sum::<i32>());
 }
 
 #[bench]
 fn iter_filter_sum_2d_u32(bench: &mut Bencher) {
     let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
     let b = a.mapv(|x| (x * 100.) as u32);
-    bench.iter(|| b.iter().filter(|&&x| x < 75).fold(0, |acc, &x| acc + x));
+    bench.iter(|| b.iter().filter(|&&x| x < 75).sum::<u32>());
 }
 
 #[bench]
 fn iter_filter_sum_2d_f32(bench: &mut Bencher) {
     let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
     let b = a * 100.;
-    bench.iter(|| b.iter().filter(|&&x| x < 75.).fold(0., |acc, &x| acc + x));
+    bench.iter(|| b.iter().filter(|&&x| x < 75.).sum::<f32>());
 }
 
 #[bench]
 fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher) {
     let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
     let b = a.mapv(|x| (x * 100.) as u32);
     let b = b.slice(s![.., ..;2]);
-    bench.iter(|| b.iter().filter(|&&x| x < 75).fold(0, |acc, &x| acc + x));
+    bench.iter(|| b.iter().filter(|&&x| x < 75).sum::<u32>());
 }
 
 #[bench]
 fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher) {
     let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap();
     let b = a * 100.;
     let b = b.slice(s![.., ..;2]);
-    bench.iter(|| b.iter().filter(|&&x| x < 75.).fold(0., |acc, &x| acc + x));
+    bench.iter(|| b.iter().filter(|&&x| x < 75.).sum::<f32>());
 }
 
 const ZIPSZ: usize = 10_000;
@@ -190,7 +196,7 @@ fn vector_sum_3_zip_unchecked_manual(bench: &mut Bencher) {
         let mut ap = a.as_ptr();
         let mut bp = b.as_ptr();
         let mut cp = c.as_mut_ptr();
-        let cend = cp.offset(c.len() as isize);
+        let cend = cp.add(c.len());
         while cp != cend {
             *cp.post_inc() += *ap.post_inc() + *bp.post_inc();
         }
@@ -310,7 +316,7 @@ fn indexed_iter_3d_dyn(bench: &mut Bencher) {
 fn iter_sum_1d_strided_fold(bench: &mut Bencher) {
     let mut a = Array::<u64, _>::ones(10240);
     a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2));
-    bench.iter(|| a.iter().fold(0, |acc, &x| acc + x));
+    bench.iter(|| a.iter().sum::<u64>());
 }
 
 #[bench]

examples/axis_ops.rs

@@ -1,3 +1,9 @@
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 extern crate ndarray;
 
 use ndarray::prelude::*;

examples/bounds_check_elim.rs

@@ -1,4 +1,10 @@
 #![crate_type = "lib"]
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 
 // Test cases for bounds check elimination
 

examples/convo.rs

@@ -28,6 +28,7 @@ where
         for i in 0..n - 2 {
             for j in 0..m - 2 {
                 let mut conv = F::zero();
+                #[allow(clippy::needless_range_loop)]
                 for k in 0..3 {
                     for l in 0..3 {
                         conv = conv + *a.uget((i + k, j + l)) * kernel[k][l];