Some Clippy lints

.travis.yml

@@ -31,7 +31,7 @@ addons:
       - libopenblas-dev
       - gfortran
 before_script:
-  - rustup component add rustfmt
+  - rustup component add rustfmt clippy
 script:
   - |
       cargo fmt --all -- --check &&

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];

examples/life.rs

@@ -1,8 +1,14 @@
+#![allow(
+    clippy::many_single_char_names,
+    clippy::deref_addrof,
+    clippy::unreadable_literal,
+    clippy::many_single_char_names
+)]
 extern crate ndarray;
 
 use ndarray::prelude::*;
 
-const INPUT: &'static [u8] = include_bytes!("life.txt");
+const INPUT: &[u8] = include_bytes!("life.txt");
 //const INPUT: &'static [u8] = include_bytes!("lifelite.txt");
 
 const N: usize = 100;
@@ -71,7 +77,7 @@ fn render(a: &Board) {
                 print!(".");
             }
         }
-        println!("");
+        println!();
     }
 }
 

examples/zip_many.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::*;

scripts/all-tests.sh

@@ -14,4 +14,5 @@ cargo test --verbose --features "$FEATURES"
 cargo test --manifest-path=serialization-tests/Cargo.toml --verbose
 cargo test --manifest-path=blas-tests/Cargo.toml --verbose
 CARGO_TARGET_DIR=target/ cargo test --manifest-path=numeric-tests/Cargo.toml --verbose
+([ "$IS_NIGHTLY" != 1 ] || cargo clippy)
 ([ "$IS_NIGHTLY" != 1 ] || cargo bench --no-run --verbose --features "$FEATURES")

src/arrayformat.rs

@@ -51,14 +51,11 @@ enum PrintableCell {
 // where indexes are being omitted.
 fn to_be_printed(length: usize, limit: usize) -> Vec<PrintableCell> {
     if length <= 2 * limit {
-        (0..length)
-            .map(|x| PrintableCell::ElementIndex(x))
-            .collect()
+        (0..length).map(PrintableCell::ElementIndex).collect()
     } else {
-        let mut v: Vec<PrintableCell> =
-            (0..limit).map(|x| PrintableCell::ElementIndex(x)).collect();
+        let mut v: Vec<PrintableCell> = (0..limit).map(PrintableCell::ElementIndex).collect();
         v.push(PrintableCell::Ellipses);
-        v.extend((length - limit..length).map(|x| PrintableCell::ElementIndex(x)));
+        v.extend((length - limit..length).map(PrintableCell::ElementIndex));
         v
     }
 }

src/data_traits.rs

@@ -133,7 +133,7 @@ pub unsafe trait DataMut: Data + RawDataMut {
 /// accessed with safe code.
 ///
 /// ***Internal trait, see `Data`.***
-#[deprecated(note = "use `Data + RawDataClone` instead", since = "0.13")]
+#[deprecated(note = "use `Data + RawDataClone` instead", since = "0.13.0")]
 pub trait DataClone: Data + RawDataClone {}
 
 #[allow(deprecated)]
@@ -241,7 +241,7 @@ unsafe impl<A> Data for OwnedArcRepr<A> {
         Self::ensure_unique(&mut self_);
         let data = OwnedRepr(Arc::try_unwrap(self_.data.0).ok().unwrap());
         ArrayBase {
-            data: data,
+            data,
             ptr: self_.ptr,
             dim: self_.dim,
             strides: self_.strides,

src/dimension/axes.rs

@@ -7,7 +7,7 @@ where
 {
     Axes {
         dim: d,
-        strides: strides,
+        strides,
         start: 0,
         end: d.ndim(),
     }
@@ -62,6 +62,9 @@ impl AxisDescription {
     pub fn stride(self) -> Ixs {
         self.2
     }
+    pub fn is_empty(self) -> bool {
+        self.len() == 0
+    }
 }
 
 copy_and_clone!(['a, D] Axes<'a, D>);

src/dimension/axis.rs

@@ -15,13 +15,13 @@ use std::cmp::Ordering;
 ///
 /// All array axis arguments use this type to make the code easier to write
 /// correctly and easier to understand.
-#[derive(Eq, Ord, Hash, Debug)]
+#[derive(Eq, Ord, Debug)]
 pub struct Axis(pub usize);
 
 impl Axis {
     /// Return the index of the axis.
     #[inline(always)]
-    pub fn index(&self) -> usize {
+    pub fn index(self) -> usize {
         self.0
     }
 }

src/dimension/dim.rs

@@ -44,7 +44,7 @@ pub struct Dim<I: ?Sized> {
 impl<I> Dim<I> {
     /// Private constructor and accessors for Dim
     pub(crate) fn new(index: I) -> Dim<I> {
-        Dim { index: index }
+        Dim { index }
     }
     #[inline(always)]
     pub(crate) fn ix(&self) -> &I {
@@ -74,6 +74,8 @@ where
     }
 }
 
+// FIXME: need help understanding why this is complaining
+#[allow(clippy::derive_hash_xor_eq)]
 impl<I: ?Sized> hash::Hash for Dim<I>
 where
     Dim<I>: Dimension,