MAINT: Use private (not visible) type params for Vec/Rc<Vec>

Related to #299

Author: bluss

src/data_traits.rs

@@ -15,6 +15,8 @@ use {
     ArrayBase,
     Dimension,
     ViewRepr,
+    OwnedRepr,
+    OwnedRcRepr,
 };
 
 /// Array representation trait.
@@ -68,15 +70,15 @@ pub unsafe trait DataClone : Data {
     }
 }
 
-unsafe impl<A> Data for Rc<Vec<A>> {
+unsafe impl<A> Data for OwnedRcRepr<A> {
     type Elem = A;
     fn _data_slice(&self) -> &[A] {
         self
     }
 }
 
 // NOTE: Copy on write
-unsafe impl<A> DataMut for Rc<Vec<A>>
+unsafe impl<A> DataMut for OwnedRcRepr<A>
     where A: Clone
 {
     fn ensure_unique<D>(self_: &mut ArrayBase<Self, D>)
@@ -112,23 +114,23 @@ unsafe impl<A> DataMut for Rc<Vec<A>>
     }
 }
 
-unsafe impl<A> DataClone for Rc<Vec<A>> {
+unsafe impl<A> DataClone for OwnedRcRepr<A> {
     unsafe fn clone_with_ptr(&self, ptr: *mut Self::Elem) -> (Self, *mut Self::Elem) {
         // pointer is preserved
         (self.clone(), ptr)
     }
 }
 
-unsafe impl<A> Data for Vec<A> {
+unsafe impl<A> Data for OwnedRepr<A> {
     type Elem = A;
     fn _data_slice(&self) -> &[A] {
         self
     }
 }
 
-unsafe impl<A> DataMut for Vec<A> { }
+unsafe impl<A> DataMut for OwnedRepr<A> { }
 
-unsafe impl<A> DataClone for Vec<A>
+unsafe impl<A> DataClone for OwnedRepr<A>
     where A: Clone
 {
     unsafe fn clone_with_ptr(&self, ptr: *mut Self::Elem) -> (Self, *mut Self::Elem) {
@@ -185,7 +187,7 @@ pub unsafe trait DataOwned : Data {
     #[doc(hidden)]
     fn new(elements: Vec<Self::Elem>) -> Self;
     #[doc(hidden)]
-    fn into_shared(self) -> Rc<Vec<Self::Elem>>;
+    fn into_shared(self) -> OwnedRcRepr<Self::Elem>;
 }
 
 /// Array representation trait.
@@ -195,23 +197,23 @@ pub unsafe trait DataOwned : Data {
 /// ***Internal trait, see `Data`.***
 pub unsafe trait DataShared : Clone + DataClone { }
 
-unsafe impl<A> DataShared for Rc<Vec<A>> {}
+unsafe impl<A> DataShared for OwnedRcRepr<A> {}
 unsafe impl<'a, A> DataShared for ViewRepr<&'a A> {}
 
-unsafe impl<A> DataOwned for Vec<A> {
+unsafe impl<A> DataOwned for OwnedRepr<A> {
     fn new(elements: Vec<A>) -> Self {
         elements
     }
-    fn into_shared(self) -> Rc<Vec<A>> {
+    fn into_shared(self) -> OwnedRcRepr<A> {
         Rc::new(self)
     }
 }
 
-unsafe impl<A> DataOwned for Rc<Vec<A>> {
+unsafe impl<A> DataOwned for OwnedRcRepr<A> {
     fn new(elements: Vec<A>) -> Self {
         Rc::new(elements)
     }
-    fn into_shared(self) -> Rc<Vec<A>> {
+    fn into_shared(self) -> OwnedRcRepr<A> {
         self
     }
 }

src/impl_owned_array.rs

@@ -2,8 +2,12 @@
 use std::rc::Rc;
 
 use imp_prelude::*;
+use {
+    OwnedRepr,
+    OwnedRcRepr,
+};
 
-impl<A, D> ArrayBase<Vec<A>, D>
+impl<A, D> ArrayBase<OwnedRepr<A>, D>
     where D: Dimension
 {
     /// Return a vector of the elements in the array, in the way they are
@@ -17,7 +21,7 @@ impl<A, D> ArrayBase<Vec<A>, D>
 }
 
 // RcArray
-impl<A, D> ArrayBase<Rc<Vec<A>>, D>
+impl<A, D> ArrayBase<OwnedRcRepr<A>, D>
     where A: Clone,
           D: Dimension
 {

src/lib.rs

@@ -504,7 +504,7 @@ pub struct ArrayBase<S, D>
 /// An array where the data has shared ownership and is copy on write.
 /// It can act as both an owner as the data as well as a shared reference (view
 /// like).
-pub type RcArray<A, D> = ArrayBase<Rc<Vec<A>>, D>;
+pub type RcArray<A, D> = ArrayBase<OwnedRcRepr<A>, D>;
 
 /// An array that owns its data uniquely.
 ///
@@ -522,7 +522,7 @@ pub type RcArray<A, D> = ArrayBase<Rc<Vec<A>>, D>;
 /// [`Array1`](Array1.t.html),
 /// [`Array2`](Array2.t.html),
 /// [`Array3`](Array3.t.html) and so on.
-pub type Array<A, D> = ArrayBase<Vec<A>, D>;
+pub type Array<A, D> = ArrayBase<OwnedRepr<A>, D>;
 
 /// A lightweight array view.
 ///
@@ -547,6 +547,12 @@ pub type ArrayView<'a, A, D> = ArrayBase<ViewRepr<&'a A>, D>;
 /// [ab]: struct.ArrayBase.html
 pub type ArrayViewMut<'a, A, D> = ArrayBase<ViewRepr<&'a mut A>, D>;
 
+/// Array's representation.
+type OwnedRepr<A> = Vec<A>;
+
+/// RcArray's representation.
+type OwnedRcRepr<A> = Rc<Vec<A>>;
+
 /// Array view’s representation.
 #[derive(Copy, Clone)]
 // This is just a marker type, to carry the lifetime parameter.