Switch from Dimension::SliceArg to CanSlice trait

Author: jturner314

blas-tests/tests/oper.rs

@@ -432,7 +432,7 @@ fn scaled_add_3() {
 
                 {
                     let mut av = a.slice_mut(s![..;s1, ..;s2]);
-                    let c = c.slice(SliceInfo::<_, IxDyn>::new(cslice).unwrap().as_ref());
+                    let c = c.slice(&SliceInfo::<_, IxDyn, IxDyn>::new(cslice).unwrap());
 
                     let mut answerv = answer.slice_mut(s![..;s1, ..;s2]);
                     answerv += &(beta * &c);

src/dimension/dimension_trait.rs

@@ -19,7 +19,7 @@ use crate::{Axis, DimMax};
 use crate::IntoDimension;
 use crate::RemoveAxis;
 use crate::{ArrayView1, ArrayViewMut1};
-use crate::{AxisSliceInfo, Dim, Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, IxDynImpl, Ixs};
+use crate::{Dim, Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, IxDynImpl, Ixs};
 
 /// Array shape and index trait.
 ///
@@ -56,21 +56,6 @@ pub trait Dimension:
     /// `Some(ndim)`, and for variable-size dimension representations (e.g.
     /// `IxDyn`), this should be `None`.
     const NDIM: Option<usize>;
-    /// `SliceArg` is the type which is used to specify slicing for this
-    /// dimension.
-    ///
-    /// For the fixed size dimensions it is a fixed size array of the correct
-    /// size, which you pass by reference. For the dynamic dimension it is
-    /// a slice.
-    ///
-    /// - For `Ix1`: `[AxisSliceInfo; 1]`
-    /// - For `Ix2`: `[AxisSliceInfo; 2]`
-    /// - and so on..
-    /// - For `IxDyn`: `[AxisSliceInfo]`
-    ///
-    /// The easiest way to create a `&SliceInfo<SliceArg, Do>` is using the
-    /// [`s![]`](macro.s!.html) macro.
-    type SliceArg: ?Sized + AsRef<[AxisSliceInfo]>;
     /// Pattern matching friendly form of the dimension value.
     ///
     /// - For `Ix1`: `usize`,
@@ -399,7 +384,6 @@ macro_rules! impl_insert_axis_array(
 
 impl Dimension for Dim<[Ix; 0]> {
     const NDIM: Option<usize> = Some(0);
-    type SliceArg = [AxisSliceInfo; 0];
     type Pattern = ();
     type Smaller = Self;
     type Larger = Ix1;
@@ -443,7 +427,6 @@ impl Dimension for Dim<[Ix; 0]> {
 
 impl Dimension for Dim<[Ix; 1]> {
     const NDIM: Option<usize> = Some(1);
-    type SliceArg = [AxisSliceInfo; 1];
     type Pattern = Ix;
     type Smaller = Ix0;
     type Larger = Ix2;
@@ -559,7 +542,6 @@ impl Dimension for Dim<[Ix; 1]> {
 
 impl Dimension for Dim<[Ix; 2]> {
     const NDIM: Option<usize> = Some(2);
-    type SliceArg = [AxisSliceInfo; 2];
     type Pattern = (Ix, Ix);
     type Smaller = Ix1;
     type Larger = Ix3;
@@ -716,7 +698,6 @@ impl Dimension for Dim<[Ix; 2]> {
 
 impl Dimension for Dim<[Ix; 3]> {
     const NDIM: Option<usize> = Some(3);
-    type SliceArg = [AxisSliceInfo; 3];
     type Pattern = (Ix, Ix, Ix);
     type Smaller = Ix2;
     type Larger = Ix4;
@@ -839,7 +820,6 @@ macro_rules! large_dim {
     ($n:expr, $name:ident, $pattern:ty, $larger:ty, { $($insert_axis:tt)* }) => (
         impl Dimension for Dim<[Ix; $n]> {
             const NDIM: Option<usize> = Some($n);
-            type SliceArg = [AxisSliceInfo; $n];
             type Pattern = $pattern;
             type Smaller = Dim<[Ix; $n - 1]>;
             type Larger = $larger;
@@ -890,7 +870,6 @@ large_dim!(6, Ix6, (Ix, Ix, Ix, Ix, Ix, Ix), IxDyn, {
 /// and memory wasteful, but it allows an arbitrary and dynamic number of axes.
 impl Dimension for IxDyn {
     const NDIM: Option<usize> = None;
-    type SliceArg = [AxisSliceInfo];
     type Pattern = Self;
     type Smaller = Self;
     type Larger = Self;

src/dimension/mod.rs

@@ -7,6 +7,7 @@
 // except according to those terms.
 
 use crate::error::{from_kind, ErrorKind, ShapeError};
+use crate::slice::CanSlice;
 use crate::{AxisSliceInfo, Ix, Ixs, Slice};
 use num_integer::div_floor;
 
@@ -596,10 +597,10 @@ fn slice_min_max(axis_len: usize, slice: Slice) -> Option<(usize, usize)> {
 /// Returns `true` iff the slices intersect.
 pub fn slices_intersect<D: Dimension>(
     dim: &D,
-    indices1: &D::SliceArg,
-    indices2: &D::SliceArg,
+    indices1: &impl CanSlice<D>,
+    indices2: &impl CanSlice<D>,
 ) -> bool {
-    debug_assert_eq!(indices1.as_ref().len(), indices2.as_ref().len());
+    debug_assert_eq!(indices1.in_ndim(), indices2.in_ndim());
     for (&axis_len, &si1, &si2) in izip!(dim.slice(), indices1.as_ref(), indices2.as_ref()) {
         // The slices do not intersect iff any pair of `AxisSliceInfo` does not intersect.
         match (si1, si2) {

src/impl_methods.rs

@@ -32,9 +32,9 @@ use crate::iter::{
     AxisChunksIter, AxisChunksIterMut, AxisIter, AxisIterMut, ExactChunks, ExactChunksMut,
     IndexedIter, IndexedIterMut, Iter, IterMut, Lanes, LanesMut, Windows,
 };
-use crate::slice::MultiSlice;
+use crate::slice::{CanSlice, MultiSlice};
 use crate::stacking::concatenate;
-use crate::{AxisSliceInfo, NdIndex, Slice, SliceInfo};
+use crate::{AxisSliceInfo, NdIndex, Slice};
 
 /// # Methods For All Array Types
 impl<A, S, D> ArrayBase<S, D>
@@ -341,9 +341,9 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice<Do>(&self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayView<'_, A, Do>
+    pub fn slice<I>(&self, info: &I) -> ArrayView<'_, A, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
         S: Data,
     {
         self.view().slice_move(info)
@@ -359,9 +359,9 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice_mut<Do>(&mut self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayViewMut<'_, A, Do>
+    pub fn slice_mut<I>(&mut self, info: &I) -> ArrayViewMut<'_, A, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
         S: DataMut,
     {
         self.view_mut().slice_move(info)
@@ -410,29 +410,37 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice_move<Do>(mut self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayBase<S, Do>
+    pub fn slice_move<I>(mut self, info: &I) -> ArrayBase<S, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
     {
         // Slice and collapse in-place without changing the number of dimensions.
-        self.slice_collapse(&*info);
+        self.slice_collapse(info);
 
-        let indices: &[AxisSliceInfo] = (**info).as_ref();
-
-        // Copy the dim and strides that remain after removing the subview axes.
         let out_ndim = info.out_ndim();
-        let mut new_dim = Do::zeros(out_ndim);
-        let mut new_strides = Do::zeros(out_ndim);
-        izip!(self.dim.slice(), self.strides.slice(), indices)
-            .filter_map(|(d, s, slice_or_index)| match slice_or_index {
-                AxisSliceInfo::Slice { .. } => Some((d, s)),
-                AxisSliceInfo::Index(_) => None,
-            })
-            .zip(izip!(new_dim.slice_mut(), new_strides.slice_mut()))
-            .for_each(|((d, s), (new_d, new_s))| {
-                *new_d = *d;
-                *new_s = *s;
+        let mut new_dim = I::OutDim::zeros(out_ndim);
+        let mut new_strides = I::OutDim::zeros(out_ndim);
+
+        // Write the dim and strides to the correct new axes.
+        {
+            let mut old_axis = 0;
+            let mut new_axis = 0;
+            info.as_ref().iter().for_each(|ax_info| match ax_info {
+                AxisSliceInfo::Slice { .. } => {
+                    // Copy the old dim and stride to corresponding axis.
+                    new_dim[new_axis] = self.dim[old_axis];
+                    new_strides[new_axis] = self.strides[old_axis];
+                    old_axis += 1;
+                    new_axis += 1;
+                }
+                AxisSliceInfo::Index(_) => {
+                    // Skip the old axis since it should be removed.
+                    old_axis += 1;
+                }
             });
+            debug_assert_eq!(old_axis, self.ndim());
+            debug_assert_eq!(new_axis, out_ndim);
+        }
 
         // safe because new dimension, strides allow access to a subset of old data
         unsafe {
@@ -442,25 +450,23 @@ where
 
     /// Slice the array in place without changing the number of dimensions.
     ///
-    /// Note that [`&SliceInfo`](struct.SliceInfo.html) (produced by the
-    /// [`s![]`](macro.s!.html) macro) will usually coerce into `&D::SliceArg`
-    /// automatically, but in some cases (e.g. if `D` is `IxDyn`), you may need
-    /// to call `.as_ref()`.
-    ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`D::SliceArg`].
-    ///
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
-    /// (**Panics** if `D` is `IxDyn` and `indices` does not match the number of array axes.)
-    pub fn slice_collapse(&mut self, indices: &D::SliceArg) {
-        let indices: &[AxisSliceInfo] = indices.as_ref();
-        assert_eq!(indices.len(), self.ndim());
-        indices
+    /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
+    pub fn slice_collapse<I>(&mut self, info: &I)
+    where
+        I: CanSlice<D>,
+    {
+        assert_eq!(
+            info.in_ndim(),
+            self.ndim(),
+            "The input dimension of `info` must match the array to be sliced.",
+        );
+        info.as_ref()
             .iter()
             .enumerate()
-            .for_each(|(axis, &slice_or_index)| match slice_or_index {
+            .for_each(|(axis, &ax_info)| match ax_info {
                 AxisSliceInfo::Slice { start, end, step } => {
                     self.slice_axis_inplace(Axis(axis), Slice { start, end, step })
                 }

src/lib.rs

@@ -141,7 +141,7 @@ pub use crate::dimension::IxDynImpl;
 pub use crate::dimension::NdIndex;
 pub use crate::error::{ErrorKind, ShapeError};
 pub use crate::indexes::{indices, indices_of};
-pub use crate::slice::{AxisSliceInfo, Slice, SliceInfo, SliceNextDim};
+pub use crate::slice::{AxisSliceInfo, Slice, SliceInfo, SliceNextInDim, SliceNextOutDim};
 
 use crate::iterators::Baseiter;
 use crate::iterators::{ElementsBase, ElementsBaseMut, Iter, IterMut, Lanes};