Rename DimAdd::Out to DimAdd::Output

Author: jturner314

src/dimension/dimension_trait.rs

@@ -55,9 +55,9 @@ pub trait Dimension:
     + DimAdd<Self>
     + DimAdd<<Self as Dimension>::Smaller>
     + DimAdd<<Self as Dimension>::Larger>
-    + DimAdd<Ix0, Out = Self>
-    + DimAdd<Ix1, Out = <Self as Dimension>::Larger>
-    + DimAdd<IxDyn, Out = IxDyn>
+    + DimAdd<Ix0, Output = Self>
+    + DimAdd<Ix1, Output = <Self as Dimension>::Larger>
+    + DimAdd<IxDyn, Output = IxDyn>
 {
     /// For fixed-size dimension representations (e.g. `Ix2`), this should be
     /// `Some(ndim)`, and for variable-size dimension representations (e.g.

src/dimension/ops.rs

@@ -3,32 +3,32 @@ use crate::imp_prelude::*;
 /// Adds the two dimensions at compile time.
 pub trait DimAdd<D: Dimension> {
     /// The sum of the two dimensions.
-    type Out: Dimension;
+    type Output: Dimension;
 }
 
 macro_rules! impl_dimadd_const_out_const {
     ($lhs:expr, $rhs:expr) => {
         impl DimAdd<Dim<[usize; $rhs]>> for Dim<[usize; $lhs]> {
-            type Out = Dim<[usize; $lhs + $rhs]>;
+            type Output = Dim<[usize; $lhs + $rhs]>;
         }
     };
 }
 
 macro_rules! impl_dimadd_const_out_dyn {
     ($lhs:expr, IxDyn) => {
         impl DimAdd<IxDyn> for Dim<[usize; $lhs]> {
-            type Out = IxDyn;
+            type Output = IxDyn;
         }
     };
     ($lhs:expr, $rhs:expr) => {
         impl DimAdd<Dim<[usize; $rhs]>> for Dim<[usize; $lhs]> {
-            type Out = IxDyn;
+            type Output = IxDyn;
         }
     };
 }
 
 impl<D: Dimension> DimAdd<D> for Ix0 {
-    type Out = D;
+    type Output = D;
 }
 
 impl_dimadd_const_out_const!(1, 0);
@@ -86,5 +86,5 @@ impl_dimadd_const_out_dyn!(6, 6);
 impl_dimadd_const_out_dyn!(6, IxDyn);
 
 impl<D: Dimension> DimAdd<D> for IxDyn {
-    type Out = IxDyn;
+    type Output = IxDyn;
 }

src/slice.rs

@@ -661,14 +661,14 @@ pub trait SliceArg {
     /// Number of dimensions that this slicing argument produces in the output array.
     type OutDim: Dimension;
 
-    fn next_in_dim<D>(&self, _: PhantomData<D>) -> PhantomData<<D as DimAdd<Self::InDim>>::Out>
+    fn next_in_dim<D>(&self, _: PhantomData<D>) -> PhantomData<<D as DimAdd<Self::InDim>>::Output>
     where
         D: Dimension + DimAdd<Self::InDim>,
     {
         PhantomData
     }
 
-    fn next_out_dim<D>(&self, _: PhantomData<D>) -> PhantomData<<D as DimAdd<Self::OutDim>>::Out>
+    fn next_out_dim<D>(&self, _: PhantomData<D>) -> PhantomData<<D as DimAdd<Self::OutDim>>::Output>
     where
         D: Dimension + DimAdd<Self::OutDim>,
     {