Rename CanSlice to SliceArg

Author: jturner314

src/dimension/mod.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use crate::error::{from_kind, ErrorKind, ShapeError};
-use crate::slice::CanSlice;
+use crate::slice::SliceArg;
 use crate::{AxisSliceInfo, Ix, Ixs, Slice};
 use num_integer::div_floor;
 
@@ -599,8 +599,8 @@ 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: &impl CanSlice<D>,
-    indices2: &impl CanSlice<D>,
+    indices1: &impl SliceArg<D>,
+    indices2: &impl SliceArg<D>,
 ) -> bool {
     debug_assert_eq!(indices1.in_ndim(), indices2.in_ndim());
     for (&axis_len, &si1, &si2) in izip!(

src/impl_methods.rs

@@ -32,7 +32,7 @@ use crate::iter::{
     AxisChunksIter, AxisChunksIterMut, AxisIter, AxisIterMut, ExactChunks, ExactChunksMut,
     IndexedIter, IndexedIterMut, Iter, IterMut, Lanes, LanesMut, Windows,
 };
-use crate::slice::{CanSlice, MultiSlice};
+use crate::slice::{MultiSlice, SliceArg};
 use crate::stacking::concatenate;
 use crate::{AxisSliceInfo, NdIndex, Slice};
 
@@ -334,16 +334,13 @@ where
     /// Return a sliced view of the array.
     ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`SliceInfo`] and [`D::SliceArg`].
-    ///
-    /// [`SliceInfo`]: struct.SliceInfo.html
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
+    /// See also [`s!`], [`SliceArg`], and [`SliceInfo`](crate::SliceInfo).
     ///
     /// **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<I>(&self, info: &I) -> ArrayView<'_, A, I::OutDim>
     where
-        I: CanSlice<D> + ?Sized,
+        I: SliceArg<D> + ?Sized,
         S: Data,
     {
         self.view().slice_move(info)
@@ -352,16 +349,13 @@ where
     /// Return a sliced read-write view of the array.
     ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`SliceInfo`] and [`D::SliceArg`].
-    ///
-    /// [`SliceInfo`]: struct.SliceInfo.html
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
+    /// See also [`s!`], [`SliceArg`], and [`SliceInfo`](crate::SliceInfo).
     ///
     /// **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<I>(&mut self, info: &I) -> ArrayViewMut<'_, A, I::OutDim>
     where
-        I: CanSlice<D> + ?Sized,
+        I: SliceArg<D> + ?Sized,
         S: DataMut,
     {
         self.view_mut().slice_move(info)
@@ -370,10 +364,7 @@ where
     /// Return multiple disjoint, sliced, mutable views of the array.
     ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`SliceInfo`] and [`D::SliceArg`].
-    ///
-    /// [`SliceInfo`]: struct.SliceInfo.html
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
+    /// See also [`s!`], [`SliceArg`], and [`SliceInfo`](crate::SliceInfo).
     ///
     /// **Panics** if any of the following occur:
     ///
@@ -403,16 +394,13 @@ where
     /// Slice the array, possibly changing the number of dimensions.
     ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`SliceInfo`] and [`D::SliceArg`].
-    ///
-    /// [`SliceInfo`]: struct.SliceInfo.html
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
+    /// See also [`s!`], [`SliceArg`], and [`SliceInfo`](crate::SliceInfo).
     ///
     /// **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<I>(mut self, info: &I) -> ArrayBase<S, I::OutDim>
     where
-        I: CanSlice<D> + ?Sized,
+        I: SliceArg<D> + ?Sized,
     {
         assert_eq!(
             info.in_ndim(),
@@ -462,6 +450,7 @@ where
     /// Slice the array in place without changing the number of dimensions.
     ///
     /// See [*Slicing*](#slicing) for full documentation.
+    /// See also [`s!`], [`SliceArg`], and [`SliceInfo`](crate::SliceInfo).
     ///
     /// **Panics** in the following cases:
     ///
@@ -472,7 +461,7 @@ where
     /// - 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> + ?Sized,
+        I: SliceArg<D> + ?Sized,
     {
         assert_eq!(
             info.in_ndim(),

src/impl_views/splitting.rs

@@ -117,12 +117,10 @@ where
     /// consumes `self` and produces views with lifetimes matching that of
     /// `self`.
     ///
-    /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`SliceInfo`] and [`D::SliceArg`].
+    /// See [*Slicing*](#slicing) for full documentation. See also [`s!`],
+    /// [`SliceArg`](crate::SliceArg), and [`SliceInfo`](crate::SliceInfo).
     ///
     /// [`.multi_slice_mut()`]: struct.ArrayBase.html#method.multi_slice_mut
-    /// [`SliceInfo`]: struct.SliceInfo.html
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
     ///
     /// **Panics** if any of the following occur:
     ///

src/lib.rs

@@ -142,7 +142,7 @@ pub use crate::dimension::NdIndex;
 pub use crate::error::{ErrorKind, ShapeError};
 pub use crate::indexes::{indices, indices_of};
 pub use crate::slice::{
-    AxisSliceInfo, CanSlice, MultiSlice, NewAxis, Slice, SliceInfo, SliceNextDim,
+    AxisSliceInfo, MultiSlice, NewAxis, Slice, SliceArg, SliceInfo, SliceNextDim,
 };
 
 use crate::iterators::Baseiter;

src/slice.rs

@@ -311,7 +311,7 @@ impl From<NewAxis> for AxisSliceInfo {
 /// that `D`, `Self::OutDim`, `self.in_dim()`, and `self.out_ndim()` are
 /// consistent with the `&[AxisSliceInfo]` returned by `self.as_ref()` and that
 /// `self.as_ref()` always returns the same value when called multiple times.
-pub unsafe trait CanSlice<D: Dimension>: AsRef<[AxisSliceInfo]> {
+pub unsafe trait SliceArg<D: Dimension>: AsRef<[AxisSliceInfo]> {
     /// Dimensionality of the output array.
     type OutDim: Dimension;
 
@@ -324,9 +324,9 @@ pub unsafe trait CanSlice<D: Dimension>: AsRef<[AxisSliceInfo]> {
     private_decl! {}
 }
 
-macro_rules! impl_canslice_samedim {
+macro_rules! impl_slicearg_samedim {
     ($in_dim:ty) => {
-        unsafe impl<T, Dout> CanSlice<$in_dim> for SliceInfo<T, $in_dim, Dout>
+        unsafe impl<T, Dout> SliceArg<$in_dim> for SliceInfo<T, $in_dim, Dout>
         where
             T: AsRef<[AxisSliceInfo]>,
             Dout: Dimension,
@@ -345,15 +345,15 @@ macro_rules! impl_canslice_samedim {
         }
     };
 }
-impl_canslice_samedim!(Ix0);
-impl_canslice_samedim!(Ix1);
-impl_canslice_samedim!(Ix2);
-impl_canslice_samedim!(Ix3);
-impl_canslice_samedim!(Ix4);
-impl_canslice_samedim!(Ix5);
-impl_canslice_samedim!(Ix6);
+impl_slicearg_samedim!(Ix0);
+impl_slicearg_samedim!(Ix1);
+impl_slicearg_samedim!(Ix2);
+impl_slicearg_samedim!(Ix3);
+impl_slicearg_samedim!(Ix4);
+impl_slicearg_samedim!(Ix5);
+impl_slicearg_samedim!(Ix6);
 
-unsafe impl<T, Din, Dout> CanSlice<IxDyn> for SliceInfo<T, Din, Dout>
+unsafe impl<T, Din, Dout> SliceArg<IxDyn> for SliceInfo<T, Din, Dout>
 where
     T: AsRef<[AxisSliceInfo]>,
     Din: Dimension,
@@ -372,7 +372,7 @@ where
     private_impl! {}
 }
 
-unsafe impl CanSlice<IxDyn> for [AxisSliceInfo] {
+unsafe impl SliceArg<IxDyn> for [AxisSliceInfo] {
     type OutDim = IxDyn;
 
     fn in_ndim(&self) -> usize {
@@ -937,7 +937,7 @@ impl<'a, A, D, I0> MultiSlice<'a, A, D> for (&I0,)
 where
     A: 'a,
     D: Dimension,
-    I0: CanSlice<D>,
+    I0: SliceArg<D>,
 {
     type Output = (ArrayViewMut<'a, A, I0::OutDim>,);
 
@@ -957,7 +957,7 @@ macro_rules! impl_multislice_tuple {
         where
             A: 'a,
             D: Dimension,
-            $($all: CanSlice<D>,)*
+            $($all: SliceArg<D>,)*
         {
             type Output = ($(ArrayViewMut<'a, A, $all::OutDim>,)*);