Allow passing owned slice arg to slicing methods

This allows the `s![]` macro to return an owned type, without
requiring an explicit `&` when calling slicing methods.

Author: jturner314

src/dimension/mod.rs

@@ -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 SliceArg<D>,
-    indices2: &impl SliceArg<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

@@ -338,9 +338,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<I>(&self, info: &I) -> ArrayView<'_, A, I::OutDim>
+    pub fn slice<I>(&self, info: I) -> ArrayView<'_, A, I::OutDim>
     where
-        I: SliceArg<D> + ?Sized,
+        I: SliceArg<D>,
         S: Data,
     {
         self.view().slice_move(info)
@@ -353,9 +353,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<I>(&mut self, info: &I) -> ArrayViewMut<'_, A, I::OutDim>
+    pub fn slice_mut<I>(&mut self, info: I) -> ArrayViewMut<'_, A, I::OutDim>
     where
-        I: SliceArg<D> + ?Sized,
+        I: SliceArg<D>,
         S: DataMut,
     {
         self.view_mut().slice_move(info)
@@ -399,9 +399,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_move<I>(mut self, info: &I) -> ArrayBase<S, I::OutDim>
+    pub fn slice_move<I>(mut self, info: I) -> ArrayBase<S, I::OutDim>
     where
-        I: SliceArg<D> + ?Sized,
+        I: SliceArg<D>,
     {
         assert_eq!(
             info.in_ndim(),
@@ -468,9 +468,9 @@ where
     /// - if [`AxisSliceInfo::NewAxis`] is in `info`, e.g. if [`NewAxis`] was
     ///   used in the [`s!`] macro
     /// - if `D` is `IxDyn` and `info` does not match the number of array axes
-    pub fn slice_collapse<I>(&mut self, info: &I)
+    pub fn slice_collapse<I>(&mut self, info: I)
     where
-        I: SliceArg<D> + ?Sized,
+        I: SliceArg<D>,
     {
         assert_eq!(
             info.in_ndim(),

src/lib.rs

@@ -492,9 +492,8 @@ pub type Ixs = isize;
 ///
 /// The slicing argument can be passed using the macro [`s![]`](macro.s!.html),
 /// which will be used in all examples. (The explicit form is an instance of
-/// [`&SliceInfo`]; see its docs for more information.)
-///
-/// [`&SliceInfo`]: struct.SliceInfo.html
+/// [`SliceInfo`] or another type which implements [`SliceArg`]; see their docs
+/// for more information.)
 ///
 /// If a range is used, the axis is preserved. If an index is used, that index
 /// is selected and the axis is removed; this selects a subview. See
@@ -510,7 +509,7 @@ pub type Ixs = isize;
 /// [`NewAxis`]: struct.NewAxis.html
 ///
 /// When slicing arrays with generic dimensionality, creating an instance of
-/// [`&SliceInfo`] to pass to the multi-axis slicing methods like [`.slice()`]
+/// [`SliceInfo`] to pass to the multi-axis slicing methods like [`.slice()`]
 /// is awkward. In these cases, it's usually more convenient to use
 /// [`.slice_each_axis()`]/[`.slice_each_axis_mut()`]/[`.slice_each_axis_inplace()`]
 /// or to create a view and then slice individual axes of the view using

src/slice.rs

@@ -78,7 +78,7 @@ pub struct NewAxis;
 /// A slice (range with step), an index, or a new axis token.
 ///
 /// See also the [`s![]`](macro.s!.html) macro for a convenient way to create a
-/// `&SliceInfo<[AxisSliceInfo; n], Din, Dout>`.
+/// `SliceInfo<[AxisSliceInfo; n], Din, Dout>`.
 ///
 /// ## Examples
 ///
@@ -721,9 +721,7 @@ impl_slicenextdim!((), NewAxis, Ix0, Ix1);
 ///
 /// `s![]` takes a list of ranges/slices/indices/new-axes, separated by comma,
 /// with optional step sizes that are separated from the range by a semicolon.
-/// It is converted into a [`&SliceInfo`] instance.
-///
-/// [`&SliceInfo`]: struct.SliceInfo.html
+/// It is converted into a [`SliceInfo`] instance.
 ///
 /// Each range/slice/index uses signed indices, where a negative value is
 /// counted from the end of the axis. Step sizes are also signed and may be
@@ -907,9 +905,7 @@ macro_rules! s(
         <$crate::AxisSliceInfo as ::std::convert::From<_>>::from($r).step_by($s as isize)
     };
     ($($t:tt)*) => {
-        // The extra `*&` is a workaround for this compiler bug:
-        // https://github.com/rust-lang/rust/issues/23014
-        &*&$crate::s![@parse
+        $crate::s![@parse
               ::std::marker::PhantomData::<$crate::Ix0>,
               ::std::marker::PhantomData::<$crate::Ix0>,
               []
@@ -951,7 +947,7 @@ where
     private_impl! {}
 }
 
-impl<'a, A, D, I0> MultiSliceArg<'a, A, D> for (&I0,)
+impl<'a, A, D, I0> MultiSliceArg<'a, A, D> for (I0,)
 where
     A: 'a,
     D: Dimension,
@@ -960,7 +956,7 @@ where
     type Output = (ArrayViewMut<'a, A, I0::OutDim>,);
 
     fn multi_slice_move(&self, view: ArrayViewMut<'a, A, D>) -> Self::Output {
-        (view.slice_move(self.0),)
+        (view.slice_move(&self.0),)
     }
 
     private_impl! {}
@@ -971,7 +967,7 @@ macro_rules! impl_multislice_tuple {
         impl_multislice_tuple!(@def_impl ($($but_last,)* $last,), [$($but_last)*] $last);
     };
     (@def_impl ($($all:ident,)*), [$($but_last:ident)*] $last:ident) => {
-        impl<'a, A, D, $($all,)*> MultiSliceArg<'a, A, D> for ($(&$all,)*)
+        impl<'a, A, D, $($all,)*> MultiSliceArg<'a, A, D> for ($($all,)*)
         where
             A: 'a,
             D: Dimension,
@@ -981,7 +977,7 @@ macro_rules! impl_multislice_tuple {
 
             fn multi_slice_move(&self, view: ArrayViewMut<'a, A, D>) -> Self::Output {
                 #[allow(non_snake_case)]
-                let &($($all,)*) = self;
+                let ($($all,)*) = self;
 
                 let shape = view.raw_dim();
                 assert!(!impl_multislice_tuple!(@intersects_self &shape, ($($all,)*)));