libstd: Add some methods to Vec<T>.

src/libstd/rt/local_heap.rs

@@ -21,7 +21,7 @@ use rt::global_heap;
 use rt::local::Local;
 use rt::task::Task;
 use raw;
-use slice::ImmutableVector;
+use slice::{ImmutableVector, Vector};
 use vec::Vec;
 
 // This has no meaning with out rtdebug also turned on.

src/libstd/str.rs

@@ -101,6 +101,7 @@ use ptr::RawPtr;
 use from_str::FromStr;
 use slice;
 use slice::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector};
+use slice::{Vector};
 use vec::Vec;
 use default::Default;
 use raw::Repr;

src/libstd/vec.rs

@@ -28,7 +28,7 @@ use ptr;
 use rt::global_heap::{malloc_raw, realloc_raw};
 use raw::Slice;
 use slice::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
-use slice::{MutableTotalOrdVector};
+use slice::{MutableTotalOrdVector, Vector};
 
 /// An owned, growable vector.
 ///
@@ -534,22 +534,6 @@ impl<T> Vec<T> {
         self.len = len;
     }
 
-    /// Work with `self` as a slice.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// fn foo(slice: &[int]) {}
-    ///
-    /// let vec = vec!(1, 2);
-    /// foo(vec.as_slice());
-    /// ```
-    #[inline]
-    pub fn as_slice<'a>(&'a self) -> &'a [T] {
-        let slice = Slice { data: self.ptr as *T, len: self.len };
-        unsafe { transmute(slice) }
-    }
-
     /// Work with `self` as a mutable slice.
     ///
     /// # Example
@@ -1172,6 +1156,24 @@ impl<T:Eq> Vec<T> {
     }
 }
 
+impl<T> Vector<T> for Vec<T> {
+    /// Work with `self` as a slice.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// fn foo(slice: &[int]) {}
+    ///
+    /// let vec = vec!(1, 2);
+    /// foo(vec.as_slice());
+    /// ```
+    #[inline]
+    fn as_slice<'a>(&'a self) -> &'a [T] {
+        let slice = Slice { data: self.ptr as *T, len: self.len };
+        unsafe { transmute(slice) }
+    }
+}
+
 /// Iterates over the `second` vector, copying each element and appending it to
 /// the `first`. Afterwards, the `first` is then returned for use again.
 ///