FEAT: Use izip!() instead of zipsl and zip_cons

Enough with the strange hacks

Author: bluss

src/dimension/dimension_trait.rs

@@ -17,7 +17,6 @@ use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, Si, IxDynImpl};
 use IntoDimension;
 use RemoveAxis;
 use {ArrayView1, ArrayViewMut1};
-use {zipsl, zipsl_mut, ZipExt};
 use Axis;
 use super::{
     stride_offset,
@@ -217,7 +216,7 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     /// Return stride offset for index.
     fn stride_offset(index: &Self, strides: &Self) -> isize {
         let mut offset = 0;
-        for (&i, &s) in zipsl(index.slice(), strides.slice()) {
+        for (&i, &s) in izip!(index.slice(), strides.slice()) {
             offset += stride_offset(i, s);
         }
         offset
@@ -251,8 +250,7 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
         ndassert!(slices.len() == dim.slice().len(),
                   "SliceArg {:?}'s length does not match dimension {:?}",
                   slices, dim);
-        for (dr, sr, &slc) in zipsl_mut(dim.slice_mut(), strides.slice_mut()).zip_cons(slices)
-        {
+        for (dr, sr, &slc) in izip!(dim.slice_mut(), strides.slice_mut(), slices) {
             let m = *dr;
             let mi = m as Ixs;
             let Si(b1, opt_e1, s1) = slc;

src/dimension/mod.rs

@@ -8,7 +8,6 @@
 
 use {Ix, Ixs};
 use error::{from_kind, ErrorKind, ShapeError};
-use {zipsl, ZipExt};
 
 pub use self::dim::*;
 pub use self::axis::Axis;
@@ -117,7 +116,7 @@ fn stride_offset_checked_arithmetic<D>(dim: &D, strides: &D, index: &D)
     where D: Dimension
 {
     let mut offset = 0;
-    for (&d, &i, &s) in zipsl(dim.slice(), index.slice()).zip_cons(strides.slice()) {
+    for (&d, &i, &s) in izip!(dim.slice(), index.slice(), strides.slice()) {
         if i >= d {
             return None;
         }
@@ -140,8 +139,7 @@ pub fn stride_offset_checked(dim: &[Ix], strides: &[Ix], index: &[Ix]) -> Option
         return None;
     }
     let mut offset = 0;
-    for (&d, &i, &s) in zipsl(dim, index).zip_cons(strides)
-    {
+    for (&d, &i, &s) in izip!(dim, index, strides) {
         if i >= d {
             return None;
         }

src/impl_methods.rs

@@ -18,8 +18,6 @@ use arraytraits;
 use dimension;
 use iterators;
 use error::{self, ShapeError, ErrorKind};
-use super::zipsl;
-use super::ZipExt;
 use dimension::IntoDimension;
 use dimension::{axes_of, Axes, merge_axes, stride_offset};
 use iterators::{
@@ -874,9 +872,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
             }
             if dim.ndim() == 1 { return false; }
             // check all dimensions -- a dimension of length 1 can have unequal strides
-            for (&dim, &s, &ds) in zipsl(dim.slice(), strides.slice())
-                .zip_cons(defaults.slice())
-            {
+            for (&dim, &s, &ds) in izip!(dim.slice(), strides.slice(), defaults.slice()) {
                 if dim != 1 && s != ds {
                     return false;
                 }

src/lib.rs

@@ -85,14 +85,12 @@ extern crate blas_sys;
 
 extern crate matrixmultiply;
 
-extern crate itertools;
+#[macro_use(izip)] extern crate itertools;
 extern crate num_traits as libnum;
 extern crate num_complex;
 
-use std::iter::Zip as ZipIter;
 use std::marker::PhantomData;
 use std::rc::Rc;
-use std::slice::{Iter as SliceIter, IterMut as SliceIterMut};
 
 pub use dimension::{
     Dimension,
@@ -816,29 +814,6 @@ pub use impl_ops::ScalarOperand;
 // Array view methods
 mod impl_views;
 
-fn zipsl<'a, 'b, A, B>(t: &'a [A], u: &'b [B])
-    -> ZipIter<SliceIter<'a, A>, SliceIter<'b, B>> {
-    t.iter().zip(u)
-}
-fn zipsl_mut<'a, 'b, A, B>(t: &'a mut [A], u: &'b mut [B])
-    -> ZipIter<SliceIterMut<'a, A>, SliceIterMut<'b, B>> {
-    t.iter_mut().zip(u)
-}
-
-use itertools::{cons_tuples, ConsTuples};
-
-trait ZipExt : Iterator {
-    fn zip_cons<J>(self, iter: J) -> ConsTuples<ZipIter<Self, J::IntoIter>, (Self::Item, J::Item)>
-        where J: IntoIterator,
-              Self: Sized,
-    {
-        cons_tuples(self.zip(iter))
-    }
-}
-
-impl<I> ZipExt for I where I: Iterator { }
-
-
 /// A contiguous array shape of n dimensions.
 ///
 /// Either c- or f- memory ordered (*c* a.k.a *row major* is the default).