nonzero baby steps

Author: max-sixty

src/dimension/mod.rs

@@ -360,8 +360,7 @@ fn to_abs_slice(axis_len: usize, slice: Slice) -> (usize, usize, isize) {
         end,
         axis_len,
     );
-    ndassert!(step != 0, "Slice stride must not be zero");
-    (start, end, step)
+    (start, end, step.get())
 }
 
 /// Modify dimension, stride and return data pointer offset

src/impl_methods.rs

@@ -413,7 +413,7 @@ where
             .enumerate()
             .for_each(|(axis, &slice_or_index)| match slice_or_index {
                 SliceOrIndex::Slice { start, end, step } => {
-                    self.slice_axis_inplace(Axis(axis), Slice { start, end, step })
+                    self.slice_axis_inplace(Axis(axis), Slice::new(start, end, step))
                 }
                 SliceOrIndex::Index(index) => {
                     let i_usize = abs_index(self.len_of(Axis(axis)), index);

src/slice.rs

@@ -9,6 +9,7 @@ use crate::error::{ErrorKind, ShapeError};
 use crate::{ArrayView, ArrayViewMut, Dimension, RawArrayViewMut};
 use std::fmt;
 use std::marker::PhantomData;
+use std::num::NonZeroIsize;
 use std::ops::{Deref, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
 
 /// A slice (range with step size).
@@ -35,7 +36,7 @@ use std::ops::{Deref, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, Rang
 pub struct Slice {
     pub start: isize,
     pub end: Option<isize>,
-    pub step: isize,
+    pub step: NonZeroIsize,
 }
 
 impl Slice {
@@ -47,25 +48,17 @@ impl Slice {
     /// `step` must be nonzero.
     /// (This method checks with a debug assertion that `step` is not zero.)
     pub fn new(start: isize, end: Option<isize>, step: isize) -> Slice {
-        debug_assert_ne!(step, 0, "Slice::new: step must be nonzero");
-        Slice { start, end, step }
-    }
-
-    /// Create a new `Slice` with the given step size (multiplied with the
-    /// previous step size).
-    ///
-    /// `step` must be nonzero.
-    /// (This method checks with a debug assertion that `step` is not zero.)
-    #[inline]
-    pub fn step_by(self, step: isize) -> Self {
-        debug_assert_ne!(step, 0, "Slice::step_by: step must be nonzero");
         Slice {
-            step: self.step * step,
-            ..self
+            start,
+            end,
+            step: NonZeroIsize::new(step).expect("Slice::new: step must be nonzero"),
         }
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
+struct Index(isize);
+
 /// A slice (range with step) or an index.
 ///
 /// See also the [`s![]`](macro.s!.html) macro for a convenient way to create a
@@ -130,7 +123,6 @@ impl SliceOrIndex {
     /// (This method checks with a debug assertion that `step` is not zero.)
     #[inline]
     pub fn step_by(self, step: isize) -> Self {
-        debug_assert_ne!(step, 0, "SliceOrIndex::step_by: step must be nonzero");
         match self {
             SliceOrIndex::Slice {
                 start,
@@ -172,57 +164,42 @@ macro_rules! impl_slice_variant_from_range {
         impl From<Range<$index>> for $self {
             #[inline]
             fn from(r: Range<$index>) -> $self {
-                $constructor {
-                    start: r.start as isize,
-                    end: Some(r.end as isize),
-                    step: 1,
-                }
+                Slice::new(r.start as isize, Some(r.end as isize), 1).into()
             }
         }
 
         impl From<RangeInclusive<$index>> for $self {
             #[inline]
             fn from(r: RangeInclusive<$index>) -> $self {
                 let end = *r.end() as isize;
-                $constructor {
-                    start: *r.start() as isize,
-                    end: if end == -1 { None } else { Some(end + 1) },
-                    step: 1,
-                }
+                Slice::new(
+                    *r.start() as isize,
+                    if end == -1 { None } else { Some(end + 1) },
+                    1,
+                )
+                .into()
             }
         }
 
         impl From<RangeFrom<$index>> for $self {
             #[inline]
             fn from(r: RangeFrom<$index>) -> $self {
-                $constructor {
-                    start: r.start as isize,
-                    end: None,
-                    step: 1,
-                }
+                Slice::new(r.start as isize, None, 1).into()
             }
         }
 
         impl From<RangeTo<$index>> for $self {
             #[inline]
             fn from(r: RangeTo<$index>) -> $self {
-                $constructor {
-                    start: 0,
-                    end: Some(r.end as isize),
-                    step: 1,
-                }
+                Slice::new(0, Some(r.end as isize), 1).into()
             }
         }
 
         impl From<RangeToInclusive<$index>> for $self {
             #[inline]
             fn from(r: RangeToInclusive<$index>) -> $self {
                 let end = r.end as isize;
-                $constructor {
-                    start: 0,
-                    end: if end == -1 { None } else { Some(end + 1) },
-                    step: 1,
-                }
+                Slice::new(0, if end == -1 { None } else { Some(end + 1) }, 1).into()
             }
         }
     };
@@ -237,11 +214,7 @@ impl_slice_variant_from_range!(SliceOrIndex, SliceOrIndex::Slice, i32);
 impl From<RangeFull> for Slice {
     #[inline]
     fn from(_: RangeFull) -> Slice {
-        Slice {
-            start: 0,
-            end: None,
-            step: 1,
-        }
+        Slice::new(0, None, 1)
     }
 }
 
@@ -262,7 +235,7 @@ impl From<Slice> for SliceOrIndex {
         SliceOrIndex::Slice {
             start: s.start,
             end: s.end,
-            step: s.step,
+            step: s.step.get(),
         }
     }
 }
@@ -610,7 +583,7 @@ macro_rules! s(
     };
     // convert range/index and step into SliceOrIndex
     (@convert $r:expr, $s:expr) => {
-        <$crate::SliceOrIndex as ::std::convert::From<_>>::from($r).step_by($s as isize)
+        <$crate::SliceOrIndex as ::std::convert::From<_>>::from($r).step_by($s)
     };
     ($($t:tt)*) => {
         // The extra `*&` is a workaround for this compiler bug:

tests/array.rs

@@ -257,7 +257,7 @@ fn test_slice_dyninput_vec_dyn() {
     let info = &SliceInfo::<_, IxDyn>::new(vec![
         SliceOrIndex::from(1..),
         SliceOrIndex::from(1),
-        SliceOrIndex::from(..).step_by(2),
+        SliceOrIndex::from(..).step_by(2isize),
     ])
     .unwrap();
     arr.slice(info.as_ref());