Update to Rust 2018 edition

Author: jturner314

.travis.yml

@@ -4,7 +4,7 @@ sudo: required
 dist: trusty
 matrix:
   include:
-    - rust: 1.30.0
+    - rust: 1.31.0
       env:
        - FEATURES='test docs'
     - rust: stable

Cargo.toml

@@ -2,6 +2,7 @@
 
 name = "ndarray"
 version = "0.12.1"
+edition = "2018"
 authors = [
   "bluss",
   "Jim Turner"

src/aliases.rs

@@ -2,15 +2,15 @@
 //!
 
 #[allow(deprecated)]
-use ::{
+use crate::{
     Ix,
     Array,
     ArrayView,
     ArrayViewMut,
     RcArray,
     IxDynImpl,
 };
-use ::dimension::Dim;
+use crate::dimension::Dim;
 
 /// Create a zero-dimensional index
 #[allow(non_snake_case)]

src/arrayformat.rs

@@ -12,7 +12,7 @@ use super::{
     Dimension,
     NdProducer,
 };
-use dimension::IntoDimension;
+use crate::dimension::IntoDimension;
 
 fn format_array<A, S, D, F>(view: &ArrayBase<S, D>, f: &mut fmt::Formatter,
                             mut format: F)
@@ -33,7 +33,7 @@ fn format_array<A, S, D, F>(view: &ArrayBase<S, D>, f: &mut fmt::Formatter,
         Some(ix) => ix,
     };
     for _ in 0..ndim {
-        try!(write!(f, "["));
+        write!(f, "[")?;
     }
     let mut first = true;
     // Simply use the indexed iterator, and take the index wraparounds
@@ -52,33 +52,33 @@ fn format_array<A, S, D, F>(view: &ArrayBase<S, D>, f: &mut fmt::Formatter,
                 // # of ['s needed
                 let n = ndim - i - 1;
                 for _ in 0..n {
-                    try!(write!(f, "]"));
+                    write!(f, "]")?;
                 }
-                try!(write!(f, ","));
-                try!(write!(f, "\n"));
+                write!(f, ",")?;
+                write!(f, "\n")?;
                 for _ in 0..ndim - n {
-                    try!(write!(f, " "));
+                    write!(f, " ")?;
                 }
                 for _ in 0..n {
-                    try!(write!(f, "["));
+                    write!(f, "[")?;
                 }
                 first = true;
                 update_index = true;
                 break;
             }
         }
         if !first {
-            try!(write!(f, ", "));
+            write!(f, ", ")?;
         }
         first = false;
-        try!(format(elt, f));
+        format(elt, f)?;
 
         if update_index {
             last_index = index;
         }
     }
     for _ in 0..ndim {
-        try!(write!(f, "]"));
+        write!(f, "]")?;
     }
     Ok(())
 }

src/arraytraits.rs

@@ -15,17 +15,17 @@ use std::ops::{
     IndexMut,
 };
 
-use imp_prelude::*;
-use iter::{
+use crate::imp_prelude::*;
+use crate::iter::{
     Iter,
     IterMut,
 };
-use {
+use crate::{
     NdIndex,
 };
 
-use numeric_util;
-use {Zip, FoldWhile};
+use crate::numeric_util;
+use crate::{Zip, FoldWhile};
 
 #[cold]
 #[inline(never)]

src/data_traits.rs

@@ -11,7 +11,7 @@
 use std::mem::{self, size_of};
 use std::sync::Arc;
 
-use {
+use crate::{
     ArrayBase,
     Dimension,
     RawViewRepr,
@@ -52,7 +52,7 @@ pub unsafe trait RawDataMut : RawData {
     /// If `Self` provides safe mutable access to array elements, then it
     /// **must** panic or ensure that the data is unique.
     #[doc(hidden)]
-    fn try_ensure_unique<D>(&mut ArrayBase<Self, D>)
+    fn try_ensure_unique<D>(_: &mut ArrayBase<Self, D>)
     where Self: Sized,
           D: Dimension;
 

src/dimension/axes.rs

@@ -1,5 +1,5 @@
 
-use {Dimension, Axis, Ix, Ixs};
+use crate::{Dimension, Axis, Ix, Ixs};
 
 /// Create a new Axes iterator
 pub fn axes_of<'a, D>(d: &'a D, strides: &'a D) -> Axes<'a, D>

src/dimension/conversion.rs

@@ -9,9 +9,9 @@
 //! Tuple to array conversion, IntoDimension, and related things
 
 use std::ops::{Index, IndexMut};
-use libnum::Zero;
+use num_traits::Zero;
 
-use {Ix, Ix1, IxDyn, Dimension, Dim, IxDynImpl};
+use crate::{Ix, Ix1, IxDyn, Dimension, Dim, IxDynImpl};
 
 /// $m: macro callback
 /// $m is called with $arg and then the indices corresponding to the size argument

src/dimension/dim.rs

@@ -12,7 +12,7 @@ use itertools::zip;
 
 use super::IntoDimension;
 use super::Dimension;
-use Ix;
+use crate::Ix;
 
 /// Dimension description.
 ///

src/dimension/dimension_trait.rs

@@ -13,11 +13,11 @@ use std::ops::{Add, Sub, Mul, AddAssign, SubAssign, MulAssign};
 
 use itertools::{enumerate, izip, zip};
 
-use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, SliceOrIndex, IxDynImpl};
-use IntoDimension;
-use RemoveAxis;
-use {ArrayView1, ArrayViewMut1};
-use Axis;
+use crate::{Ix, Ixs, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, SliceOrIndex, IxDynImpl};
+use crate::IntoDimension;
+use crate::RemoveAxis;
+use crate::{ArrayView1, ArrayViewMut1};
+use crate::Axis;
 use super::{
     stride_offset,
     stride_offset_checked,

src/dimension/dynindeximpl.rs

@@ -5,7 +5,7 @@ use std::ops::{
     Deref,
     DerefMut,
 };
-use imp_prelude::*;
+use crate::imp_prelude::*;
 
 const CAP: usize = 4;
 
@@ -53,7 +53,7 @@ impl Default for IxDynRepr<Ix> {
 }
 
 
-use ::libnum::Zero;
+use num_traits::Zero;
 
 impl<T: Copy + Zero> IxDynRepr<T> {
     pub fn copy_from(x: &[T]) -> Self {

src/dimension/mod.rs

@@ -6,8 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use {Ix, Ixs};
-use error::{from_kind, ErrorKind, ShapeError};
+use crate::{Ix, Ixs};
+use crate::error::{from_kind, ErrorKind, ShapeError};
 use itertools::izip;
 
 pub use self::dim::*;
@@ -424,9 +424,9 @@ mod test {
     use super::{
         can_index_slice, can_index_slice_not_custom, max_abs_offset_check_overflow, IntoDimension
     };
-    use error::{from_kind, ErrorKind};
+    use crate::error::{from_kind, ErrorKind};
     use quickcheck::quickcheck;
-    use {Dimension, Ix0, Ix1, Ix2, Ix3, IxDyn};
+    use crate::{Dimension, Ix0, Ix1, Ix2, Ix3, IxDyn};
 
     #[test]
     fn slice_indexing_uncommon_strides() {

src/dimension/ndindex.rs

@@ -3,10 +3,7 @@ use std::fmt::Debug;
 
 use itertools::zip;
 
-use {Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, Dimension, IntoDimension};
-use {
-    IxDynImpl,
-};
+use crate::{Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, IxDynImpl, Dim, Dimension, IntoDimension};
 use super::{stride_offset, stride_offset_checked};
 
 /// Tuple or fixed size arrays that can be used to index an array.

src/dimension/remove_axis.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 
-use {Ix, Ix0, Ix1, Dimension, Dim, Axis};
+use crate::{Ix, Ix0, Ix1, Dimension, Dim, Axis};
 
 /// Array shape with a next smaller dimension.
 ///

src/free_functions.rs

@@ -9,8 +9,8 @@
 use std::slice;
 use std::mem::{size_of, forget};
 
-use dimension;
-use imp_prelude::*;
+use crate::dimension;
+use crate::imp_prelude::*;
 
 /// Create an [**`Array`**](type.Array.html) with one, two or
 /// three dimensions.

src/impl_1d.rs

@@ -8,7 +8,7 @@
 
 
 //! Methods for one-dimensional arrays.
-use imp_prelude::*;
+use crate::imp_prelude::*;
 
 /// # Methods For 1-D Arrays
 impl<A, S> ArrayBase<S, Ix1>
@@ -23,7 +23,7 @@ impl<A, S> ArrayBase<S, Ix1>
         if let Some(slc) = self.as_slice() {
             slc.to_vec()
         } else {
-            ::iterators::to_vec(self.iter().map(|x| x.clone()))
+            crate::iterators::to_vec(self.iter().map(|x| x.clone()))
         }
     }
 }

src/impl_2d.rs

@@ -8,7 +8,7 @@
 
 
 //! Methods for two-dimensional arrays.
-use imp_prelude::*;
+use crate::imp_prelude::*;
 
 /// # Methods For 2-D Arrays
 impl<A, S> ArrayBase<S, Ix2>

src/impl_clone.rs

@@ -5,8 +5,8 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use imp_prelude::*;
-use RawDataClone;
+use crate::imp_prelude::*;
+use crate::RawDataClone;
 
 impl<S: RawDataClone, D: Clone> Clone for ArrayBase<S, D> {
     fn clone(&self) -> ArrayBase<S, D> {

src/impl_constructors.rs

@@ -10,18 +10,18 @@
 //!
 //!
 
-use libnum::{Zero, One, Float};
+use num_traits::{Zero, One, Float};
 use std::isize;
 use std::mem;
 
-use imp_prelude::*;
-use StrideShape;
-use dimension;
-use linspace;
-use error::{self, ShapeError};
-use indices;
-use indexes;
-use iterators::{to_vec, to_vec_mapped};
+use crate::imp_prelude::*;
+use crate::StrideShape;
+use crate::dimension;
+use crate::linspace;
+use crate::error::{self, ShapeError};
+use crate::indices;
+use crate::indexes;
+use crate::iterators::{to_vec, to_vec_mapped};
 
 /// # Constructor Methods for Owned Arrays
 ///

src/impl_dyn.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 //! Methods for dynamic-dimensional arrays.
-use imp_prelude::*;
+use crate::imp_prelude::*;
 
 /// # Methods for Dynamic-Dimensional Arrays
 impl<A, S> ArrayBase<S, IxDyn>