Merge pull request #567 from jturner314/rust-2018

Update ndarray 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/array_serde.rs

@@ -12,11 +12,11 @@ use serde::ser::{SerializeSeq, SerializeStruct};
 use std::fmt;
 use std::marker::PhantomData;
 
-use imp_prelude::*;
+use crate::imp_prelude::*;
 
 use super::arraytraits::ARRAY_FORMAT_VERSION;
 use super::Iter;
-use IntoDimension;
+use crate::IntoDimension;
 
 /// Verifies that the version of the deserialized array matches the current
 /// `ARRAY_FORMAT_VERSION`.
@@ -25,10 +25,10 @@ pub fn verify_version<E>(v: u8) -> Result<(), E>
 {
     if v != ARRAY_FORMAT_VERSION {
         let err_msg = format!("unknown array version: {}", v);
-        try!(Err(de::Error::custom(err_msg)));
+        Err(de::Error::custom(err_msg))
+    } else {
+        Ok(())
     }
-
-    Ok(())
 }
 
 /// **Requires crate feature `"serde-1"`**
@@ -84,10 +84,10 @@ impl<A, D, S> Serialize for ArrayBase<S, D>
     fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
         where Se: Serializer
     {
-        let mut state = try!(serializer.serialize_struct("Array", 3));
-        try!(state.serialize_field("v", &ARRAY_FORMAT_VERSION));
-        try!(state.serialize_field("dim", &self.raw_dim()));
-        try!(state.serialize_field("data", &Sequence(self.iter())));
+        let mut state = serializer.serialize_struct("Array", 3)?;
+        state.serialize_field("v", &ARRAY_FORMAT_VERSION)?;
+        state.serialize_field("dim", &self.raw_dim())?;
+        state.serialize_field("data", &Sequence(self.iter()))?;
         state.end()
     }
 }
@@ -103,9 +103,9 @@ impl<'a, A, D> Serialize for Sequence<'a, A, D>
         where S: Serializer
     {
         let iter = &self.0;
-        let mut seq = try!(serializer.serialize_seq(Some(iter.len())));
+        let mut seq = serializer.serialize_seq(Some(iter.len()))?;
         for elt in iter.clone() {
-            try!(seq.serialize_element(elt));
+            seq.serialize_element(elt)?;
         }
         seq.end()
     }
@@ -197,23 +197,23 @@ impl<'de, A, Di, S> Visitor<'de> for ArrayVisitor<S,Di>
     fn visit_seq<V>(self, mut visitor: V) -> Result<ArrayBase<S, Di>, V::Error>
         where V: SeqAccess<'de>,
     {
-        let v: u8 = match try!(visitor.next_element()) {
+        let v: u8 = match visitor.next_element()? {
             Some(value) => value,
             None => {
                 return Err(de::Error::invalid_length(0, &self));
             }
         };
 
-        try!(verify_version(v));
+        verify_version(v)?;
 
-        let dim: Di = match try!(visitor.next_element()) {
+        let dim: Di = match visitor.next_element()? {
             Some(value) => value,
             None => {
                 return Err(de::Error::invalid_length(1, &self));
             }
         };
 
-        let data: Vec<A> = match try!(visitor.next_element()) {
+        let data: Vec<A> = match visitor.next_element()? {
             Some(value) => value,
             None => {
                 return Err(de::Error::invalid_length(2, &self));
@@ -234,35 +234,35 @@ impl<'de, A, Di, S> Visitor<'de> for ArrayVisitor<S,Di>
         let mut data: Option<Vec<A>> = None;
         let mut dim: Option<Di> = None;
 
-        while let Some(key) = try!(visitor.next_key()) {
+        while let Some(key) = visitor.next_key()? {
             match key {
                 ArrayField::Version => {
-                    let val = try!(visitor.next_value());
-                    try!(verify_version(val));
+                    let val = visitor.next_value()?;
+                    verify_version(val)?;
                     v = Some(val);
                 },
                 ArrayField::Data => {
-                    data = Some(try!(visitor.next_value()));
+                    data = Some(visitor.next_value()?);
                 },
                 ArrayField::Dim => {
-                    dim = Some(try!(visitor.next_value()));
+                    dim = Some(visitor.next_value()?);
                 },
             }
         }
 
         let _v = match v {
             Some(v) => v,
-            None => try!(Err(de::Error::missing_field("v"))),
+            None => Err(de::Error::missing_field("v"))?,
         };
 
         let data = match data {
             Some(data) => data,
-            None => try!(Err(de::Error::missing_field("data"))),
+            None => Err(de::Error::missing_field("data"))?,
         };
 
         let dim = match dim {
             Some(dim) => dim,
-            None => try!(Err(de::Error::missing_field("dim"))),
+            None => Err(de::Error::missing_field("dim"))?,
         };
 
         if let Ok(array) = ArrayBase::from_shape_vec(dim, data) {

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.
 ///