Adjustments from review

src/libcollections/slice.rs

@@ -831,7 +831,7 @@ pub trait CloneSliceExt<T> for Sized? {
     /// assert_eq!(Some(vec![1i, 3, 2]), perms.next());
     /// assert_eq!(Some(vec![3i, 1, 2]), perms.next());
     /// ```
-    #[stable]
+    #[unstable]
     fn permutations(&self) -> Permutations<T>;
 
     /// Copies as many elements from `src` as it can into `self` (the
@@ -950,7 +950,7 @@ pub trait OrdSliceExt<T> for Sized? {
     /// let b: &mut [_] = &mut [1i, 0, 2];
     /// assert!(v == b);
     /// ```
-    #[stable]
+    #[unstable = "uncertain if this merits inclusion in std"]
     fn next_permutation(&mut self) -> bool;
 
     /// Mutates the slice to the previous lexicographic permutation.
@@ -969,7 +969,7 @@ pub trait OrdSliceExt<T> for Sized? {
     /// let b: &mut [_] = &mut [0i, 1, 2];
     /// assert!(v == b);
     /// ```
-    #[stable]
+    #[unstable = "uncertain if this merits inclusion in std"]
     fn prev_permutation(&mut self) -> bool;
 }
 
@@ -1165,7 +1165,7 @@ impl Iterator<(uint, uint)> for ElementSwaps {
 /// swap applied.
 ///
 /// Generates even and odd permutations alternately.
-#[stable]
+#[unstable]
 pub struct Permutations<T> {
     swaps: ElementSwaps,
     v: Vec<T>,

src/libcollections/vec.rs

@@ -261,7 +261,7 @@ impl<T> Vec<T> {
     /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector
     /// without cloning, as if `ptr::read()` were called on them.
     #[inline]
-    #[stable]
+    #[unstable = "may be better expressed via composition"]
     pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
         let mut dst = Vec::with_capacity(elts);
         dst.set_len(elts);

src/libcore/iter.rs

@@ -691,13 +691,14 @@ pub trait IteratorExt<A>: Iterator<A> {
 impl<A, I> IteratorExt<A> for I where I: Iterator<A> {}
 
 /// Extention trait for iterators of pairs.
+#[unstable = "newly added trait, likely to be merged with IteratorExt"]
 pub trait IteratorPairExt<A, B>: Iterator<(A, B)> {
     /// Converts an iterator of pairs into a pair of containers.
     ///
     /// Loops through the entire iterator, collecting the first component of
     /// each item into one new container, and the second component into another.
     fn unzip<FromA, FromB>(mut self) -> (FromA, FromB) where
-        FromA: FromIterator<A> + Extend<A>, FromB: FromIterator<B> + Extend<B>
+        FromA: Default + Extend<A>, FromB: Default + Extend<B>
     {
         struct SizeHint<A>(uint, Option<uint>);
         impl<A> Iterator<A> for SizeHint<A> {
@@ -708,8 +709,11 @@ pub trait IteratorPairExt<A, B>: Iterator<(A, B)> {
         }
 
         let (lo, hi) = self.size_hint();
-        let mut ts: FromA = FromIterator::from_iter(SizeHint(lo, hi));
-        let mut us: FromB = FromIterator::from_iter(SizeHint(lo, hi));
+        let mut ts: FromA = Default::default();
+        let mut us: FromB = Default::default();
+
+        ts.extend(SizeHint(lo, hi));
+        us.extend(SizeHint(lo, hi));
 
         for (t, u) in self {
             ts.extend(Some(t).into_iter());