Stabilization of impls and fallout from stabilization

diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 88f02d6573eac788f930391f1c393873cb7b1c52..25f80ad11bd1124b87ef34445b799b4dd67f80cf 100644 (file)
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -246,7 +246,7 @@ fn borrow_from(owned: &Arc<T>) -> &T {
     }
 }
 
-#[experimental = "Deref is experimental."]
+#[stable]
 impl<T> Deref for Arc<T> {
     type Target = T;
 
@@ -290,7 +290,7 @@ pub fn make_unique(&mut self) -> &mut T {
 }
 
 #[unsafe_destructor]
-#[experimental = "waiting on stability of Drop"]
+#[stable]
 impl<T: Sync + Send> Drop for Arc<T> {
     /// Drops the `Arc<T>`.
     ///
@@ -418,7 +418,7 @@ fn clone(&self) -> Weak<T> {
 }
 
 #[unsafe_destructor]
-#[experimental = "Weak pointers may not belong in this module."]
+#[stable]
 impl<T: Sync + Send> Drop for Weak<T> {
     /// Drops the `Weak<T>`.
     ///

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 2c318181b099521fc88e0f9f54c15da0dbc12b77..33d1cc7f4c74596cbc23ba54485eec44c3dbffc8 100644 (file)
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -155,12 +155,14 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
+#[stable]
 impl<Sized? T> Deref for Box<T> {
     type Target = T;
 
     fn deref(&self) -> &T { &**self }
 }
 
+#[stable]
 impl<Sized? T> DerefMut for Box<T> {
     fn deref_mut(&mut self) -> &mut T { &mut **self }
 }

diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index c4b455aff5c53cea59eecc9ff87489e29bb1d731..175bba4e71dc46f9671f04658e5a3b034914a43e 100644 (file)
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -354,7 +354,7 @@ fn borrow_from(owned: &Rc<T>) -> &T {
     }
 }
 
-#[experimental = "Deref is experimental."]
+#[stable]
 impl<T> Deref for Rc<T> {
     type Target = T;
 
@@ -365,7 +365,7 @@ fn deref(&self) -> &T {
 }
 
 #[unsafe_destructor]
-#[experimental = "Drop is experimental."]
+#[stable]
 impl<T> Drop for Rc<T> {
     /// Drops the `Rc<T>`.
     ///
@@ -656,7 +656,7 @@ pub fn upgrade(&self) -> Option<Rc<T>> {
 }
 
 #[unsafe_destructor]
-#[experimental = "Weak pointers may not belong in this module."]
+#[stable]
 impl<T> Drop for Weak<T> {
     /// Drops the `Weak<T>`.
     ///

diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
index 619a6e9427199718da835c9911cfecbda1369edd..01693391abed51037186c9f781eca4141ae148b9 100644 (file)
--- a/src/libcollections/binary_heap.rs
+++ b/src/libcollections/binary_heap.rs
@@ -562,11 +562,13 @@ pub fn drain(&mut self) -> Drain<T> {
 }
 
 /// `BinaryHeap` iterator.
+#[stable]
 pub struct Iter <'a, T: 'a> {
     iter: slice::Iter<'a, T>,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
+#[stable]
 impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> {
         Iter { iter: self.iter.clone() }
@@ -594,6 +596,7 @@ fn next_back(&mut self) -> Option<&'a T> { self.iter.next_back() }
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 /// An iterator that moves out of a `BinaryHeap`.
+#[stable]
 pub struct IntoIter<T> {
     iter: vec::IntoIter<T>,
 }
@@ -619,6 +622,7 @@ fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// An iterator that drains a `BinaryHeap`.
+#[unstable = "recent addition"]
 pub struct Drain<'a, T: 'a> {
     iter: vec::Drain<'a, T>,
 }

diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 72cdae8ba310292fa0d1a81be40763f92c47272b..c9b090bfb232373551710a94052cb03c1a1ba66e 100644 (file)
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -113,8 +113,7 @@ mod prelude {
     pub use core::iter::range;
     pub use core::iter::{FromIterator, Extend, IteratorExt};
     pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator};
-    pub use core::iter::{IteratorCloneExt, CloneIteratorExt};
-    pub use core::iter::{IteratorOrdExt, MutableDoubleEndedIterator, ExactSizeIterator};
+    pub use core::iter::{ExactSizeIterator};
     pub use core::kinds::{Copy, Send, Sized, Sync};
     pub use core::mem::drop;
     pub use core::ops::{Drop, Fn, FnMut, FnOnce};

diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index ceccca561aec794651afffff172bbcde70678a79..e3bf5d63b1dfde37713086a565e7159d43b6f1ca 100644 (file)
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -1092,6 +1092,7 @@ struct SizeDirection {
     dir: Direction,
 }
 
+#[stable]
 impl Iterator for ElementSwaps {
     type Item = (uint, uint);
 

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index ecf17820d2d8f72c58f44bc97d18c59a3b8666e9..9f3ab6dd5c0cb4fa249d84228154ea2447ce218d 100644 (file)
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -165,6 +165,7 @@ enum DecompositionType {
 /// External iterator for a string's decomposition's characters.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[unstable]
 pub struct Decompositions<'a> {
     kind: DecompositionType,
     iter: Chars<'a>,
@@ -172,6 +173,7 @@ pub struct Decompositions<'a> {
     sorted: bool
 }
 
+#[stable]
 impl<'a> Iterator for Decompositions<'a> {
     type Item = char;
 
@@ -253,6 +255,7 @@ enum RecompositionState {
 /// External iterator for a string's recomposition's characters.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[unstable]
 pub struct Recompositions<'a> {
     iter: Decompositions<'a>,
     state: RecompositionState,
@@ -261,6 +264,7 @@ pub struct Recompositions<'a> {
     last_ccc: Option<u8>
 }
 
+#[stable]
 impl<'a> Iterator for Recompositions<'a> {
     type Item = char;
 
@@ -348,10 +352,12 @@ fn next(&mut self) -> Option<char> {
 /// External iterator for a string's UTF16 codeunits.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[unstable]
 pub struct Utf16Units<'a> {
     encoder: Utf16Encoder<Chars<'a>>
 }
 
+#[stable]
 impl<'a> Iterator for Utf16Units<'a> {
     type Item = u16;
 

diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index e7451331908aed9e8fdf2fefb3ed60790b63e9dc..8ffca7e57b20eabe3f7a8e6d9f44d509a14074e1 100644 (file)
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -711,7 +711,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
-#[experimental = "waiting on FromIterator stabilization"]
+#[stable]
 impl FromIterator<char> for String {
     fn from_iter<I:Iterator<Item=char>>(iterator: I) -> String {
         let mut buf = String::new();
@@ -720,7 +720,7 @@ fn from_iter<I:Iterator<Item=char>>(iterator: I) -> String {
     }
 }
 
-#[experimental = "waiting on FromIterator stabilization"]
+#[stable]
 impl<'a> FromIterator<&'a str> for String {
     fn from_iter<I:Iterator<Item=&'a str>>(iterator: I) -> String {
         let mut buf = String::new();
@@ -832,7 +832,7 @@ fn hash(&self, hasher: &mut H) {
     }
 }
 
-#[experimental = "waiting on Add stabilization"]
+#[unstable = "recent addition, needs more experience"]
 impl<'a> Add<&'a str> for String {
     type Output = String;
 
@@ -864,7 +864,7 @@ fn slice_or_fail<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
     }
 }
 
-#[experimental = "waiting on Deref stabilization"]
+#[stable]
 impl ops::Deref for String {
     type Target = str;
 

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index b8f97799c971872b1245b2ed15e0110afa35d54d..b8bcba84cee0867599e63a6340b4bb66a3518229 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1272,19 +1272,19 @@ fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T]
     }
 }
 
-#[experimental = "waiting on Deref stability"]
+#[stable]
 impl<T> ops::Deref for Vec<T> {
     type Target = [T];
 
     fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
 }
 
-#[experimental = "waiting on DerefMut stability"]
+#[stable]
 impl<T> ops::DerefMut for Vec<T> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
 }
 
-#[experimental = "waiting on FromIterator stability"]
+#[stable]
 impl<T> FromIterator<T> for Vec<T> {
     #[inline]
     fn from_iter<I:Iterator<Item=T>>(mut iterator: I) -> Vec<T> {
@@ -1414,6 +1414,7 @@ fn as_slice<'a>(&'a self) -> &'a [T] {
     }
 }
 
+#[unstable = "recent addition, needs more experience"]
 impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
     type Output = Vec<T>;
 
@@ -1425,6 +1426,7 @@ fn add(mut self, rhs: &[T]) -> Vec<T> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {
         // This is (and should always remain) a no-op if the fields are
@@ -1470,6 +1472,7 @@ fn write_str(&mut self, s: &str) -> fmt::Result {
 /// A clone-on-write vector
 pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>;
 
+#[unstable]
 impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
     fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
         Cow::Owned(FromIterator::from_iter(it))
@@ -1515,6 +1518,7 @@ pub fn into_inner(mut self) -> Vec<T> {
     }
 }
 
+#[stable]
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
@@ -1551,6 +1555,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back<'a>(&'a mut self) -> Option<T> {
@@ -1574,9 +1579,11 @@ fn next_back<'a>(&'a mut self) -> Option<T> {
     }
 }
 
+#[stable]
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 #[unsafe_destructor]
+#[stable]
 impl<T> Drop for IntoIter<T> {
     fn drop(&mut self) {
         // destroy the remaining elements
@@ -1598,6 +1605,7 @@ pub struct Drain<'a, T> {
     marker: ContravariantLifetime<'a>,
 }
 
+#[stable]
 impl<'a, T> Iterator for Drain<'a, T> {
     type Item = T;
 
@@ -1634,6 +1642,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
@@ -1657,9 +1666,11 @@ fn next_back(&mut self) -> Option<T> {
     }
 }
 
+#[stable]
 impl<'a, T> ExactSizeIterator for Drain<'a, T> {}
 
 #[unsafe_destructor]
+#[stable]
 impl<'a, T> Drop for Drain<'a, T> {
     fn drop(&mut self) {
         // self.ptr == self.end == null if drop has already been called,
@@ -1692,7 +1703,7 @@ fn deref<'b>(&'b self) -> &'b Vec<T> {
 
 // Prevent the inner `Vec<T>` from attempting to deallocate memory.
 #[unsafe_destructor]
-#[experimental]
+#[stable]
 impl<'a, T> Drop for DerefVec<'a, T> {
     fn drop(&mut self) {
         self.x.len = 0;

diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs
index 7e4d73d598d8d8227bed2325082170b019a34f15..63b3be00f55f5fe79608a0c294e8c702e384f19d 100644 (file)
--- a/src/libcore/borrow.rs
+++ b/src/libcore/borrow.rs
@@ -191,6 +191,7 @@ pub fn is_owned(&self) -> bool {
     }
 }
 
+#[stable]
 impl<'a, T, Sized? B> Deref for Cow<'a, T, B> where B: ToOwned<T>  {
     type Target = B;
 

diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index eb772388dce220834d000638830ab1986f8a27d5..fd18d6ac3f3b409e389b599e5292343feccb720f 100644 (file)
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -419,7 +419,7 @@ pub struct Ref<'b, T:'b> {
     _borrow: BorrowRef<'b>,
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
+#[stable]
 impl<'b, T> Deref for Ref<'b, T> {
     type Target = T;
 
@@ -477,7 +477,7 @@ pub struct RefMut<'b, T:'b> {
     _borrow: BorrowRefMut<'b>,
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
+#[stable]
 impl<'b, T> Deref for RefMut<'b, T> {
     type Target = T;
 
@@ -487,7 +487,7 @@ fn deref<'a>(&'a self) -> &'a T {
     }
 }
 
-#[unstable = "waiting for `DerefMut` to become stable"]
+#[stable]
 impl<'b, T> DerefMut for RefMut<'b, T> {
     #[inline]
     fn deref_mut<'a>(&'a mut self) -> &'a mut T {

diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 291b7f2ece4455db05cd8777785240795501f5d2..caac894c0daa327c5ccf98edb285de9014b7fa08 100644 (file)
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -314,6 +314,7 @@ pub struct EscapeUnicode {
 }
 
 #[derive(Clone)]
+#[unstable]
 enum EscapeUnicodeState {
     Backslash,
     Type,
@@ -375,6 +376,7 @@ pub struct EscapeDefault {
 }
 
 #[derive(Clone)]
+#[unstable]
 enum EscapeDefaultState {
     Backslash(char),
     Char(char),

diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 4782a763dc89a425b9f2c18bd8f5bafe92390ccd..e5753f6cc2e7857e6e76c3a7cc3d4eaa5e151b89 100644 (file)
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -2401,7 +2401,7 @@ pub fn new(initial_state: St, f: F) -> Unfold<A, St, F> {
     }
 }
 
-#[experimental]
+#[stable]
 impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
     type Item = A;
 

diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index da2e95832e71aa00a99c33693084707e0c53343c..74702c66f7ba58e8bb4ee426764df38fbdfc8cd7 100644 (file)
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -984,6 +984,7 @@ pub struct Range<Idx> {
 
 // FIXME(#19391) needs a snapshot
 //impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> Iterator for Range<Idx> {
     type Item = Idx;
 
@@ -1008,6 +1009,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     #[inline]
     fn next_back(&mut self) -> Option<Idx> {
@@ -1020,6 +1022,7 @@ fn next_back(&mut self) -> Option<Idx> {
     }
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
 
 /// A range which is only bounded below.
@@ -1031,6 +1034,7 @@ pub struct RangeFrom<Idx> {
     pub start: Idx,
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
     type Item = Idx;
 

diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index a9a1857ec97bf3764f91da9751ce60675447600d..39d0f024d4d4143f63c1419065d42481b8b5beb8 100644 (file)
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -807,6 +807,7 @@ impl<A> ExactSizeIterator for Item<A> {}
 #[stable]
 pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
 
+#[stable]
 impl<'a, A> Iterator for Iter<'a, A> {
     type Item = &'a A;
 
@@ -816,11 +817,13 @@ fn next(&mut self) -> Option<&'a A> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
 
 #[stable]
@@ -834,6 +837,7 @@ fn clone(&self) -> Iter<'a, A> {
 #[stable]
 pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
 
+#[stable]
 impl<'a, A> Iterator for IterMut<'a, A> {
     type Item = &'a mut A;
 
@@ -843,17 +847,20 @@ fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
 
 /// An iterator over the item contained inside an Option.
 #[stable]
 pub struct IntoIter<A> { inner: Item<A> }
 
+#[stable]
 impl<A> Iterator for IntoIter<A> {
     type Item = A;
 
@@ -863,11 +870,13 @@ fn next(&mut self) -> Option<A> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<A> DoubleEndedIterator for IntoIter<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<A> ExactSizeIterator for IntoIter<A> {}
 
 /////////////////////////////////////////////////////////////////////////////

diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index d4aca1bb73c23659e987f6774abfc3c64708cef9..e88cb73c8a9b7f6f8d7b6f1a0a6c1207febc3f0d 100644 (file)
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -43,8 +43,7 @@
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use iter::{Extend, IteratorExt};
 pub use iter::{Iterator, DoubleEndedIterator};
-pub use iter::{IteratorCloneExt, CloneIteratorExt};
-pub use iter::{IteratorOrdExt, ExactSizeIterator};
+pub use iter::{ExactSizeIterator};
 pub use option::Option::{self, Some, None};
 pub use ptr::{PtrExt, MutPtrExt};
 pub use result::Result::{self, Ok, Err};

diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 7135faaa76516aa257ab14ea37f4cf44eeb179a9..7293ed6455b084aa74cd5932a0b494b75cc99ec8 100644 (file)
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -807,6 +807,7 @@ fn as_slice<'a>(&'a self) -> &'a [T] {
 #[stable]
 pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
 
+#[stable]
 impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
 
@@ -819,11 +820,13 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
 }
 
+#[stable]
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 impl<'a, T> Clone for Iter<'a, T> {
@@ -834,6 +837,7 @@ fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } }
 #[stable]
 pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
 
+#[stable]
 impl<'a, T> Iterator for IterMut<'a, T> {
     type Item = &'a mut T;
 
@@ -846,17 +850,20 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
 }
 
+#[stable]
 impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// An iterator over the value in a `Ok` variant of a `Result`.
 #[stable]
 pub struct IntoIter<T> { inner: Option<T> }
 
+#[stable]
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
@@ -869,11 +876,13 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> { self.inner.take() }
 }
 
+#[stable]
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /////////////////////////////////////////////////////////////////////////////

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 8174596e65e520a0b355bfeba7f4f23fc10910f3..7161bfdcd5a9ed02e4a487b5d8e060b112dc78ba 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -672,7 +672,7 @@ fn default() -> &'a [T] { &[] }
 // The shared definition of the `Iter` and `IterMut` iterators
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {
-        #[experimental = "needs review"]
+        #[stable]
         impl<'a, T> Iterator for $name<'a, T> {
             type Item = $elem;
 
@@ -710,7 +710,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
             }
         }
 
-        #[experimental = "needs review"]
+        #[stable]
         impl<'a, T> DoubleEndedIterator for $name<'a, T> {
             #[inline]
             fn next_back(&mut self) -> Option<$elem> {
@@ -793,7 +793,7 @@ impl<'a,T> Copy for Iter<'a,T> {}
 
 iterator!{struct Iter -> *const T, &'a T}
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 #[stable]
@@ -801,7 +801,7 @@ impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> { *self }
 }
 
-#[experimental = "needs review"]
+#[experimental = "trait is experimental"]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -887,7 +887,7 @@ pub fn into_slice(self) -> &'a mut [T] {
 
 iterator!{struct IterMut -> *mut T, &'a mut T}
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// An internal abstraction over the splitting iterators, so that
@@ -919,7 +919,7 @@ fn clone(&self) -> Split<'a, T, P> {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     type Item = &'a [T];
 
@@ -947,7 +947,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
@@ -992,7 +992,7 @@ fn finish(&mut self) -> Option<&'a mut [T]> {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     type Item = &'a mut [T];
 
@@ -1027,7 +1027,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
     P: FnMut(&T) -> bool,
 {
@@ -1060,7 +1060,6 @@ struct GenericSplitN<I> {
     invert: bool
 }
 
-#[experimental = "needs review"]
 impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
     type Item = T;
 
@@ -1113,6 +1112,7 @@ pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
 
 macro_rules! forward_iterator {
     ($name:ident: $elem:ident, $iter_of:ty) => {
+        #[stable]
         impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
             P: FnMut(&T) -> bool
         {
@@ -1144,6 +1144,7 @@ pub struct Windows<'a, T:'a> {
     size: uint
 }
 
+#[stable]
 impl<'a, T> Iterator for Windows<'a, T> {
     type Item = &'a [T];
 
@@ -1181,7 +1182,7 @@ pub struct Chunks<'a, T:'a> {
     size: uint
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> Iterator for Chunks<'a, T> {
     type Item = &'a [T];
 
@@ -1210,7 +1211,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
@@ -1226,7 +1227,7 @@ fn next_back(&mut self) -> Option<&'a [T]> {
     }
 }
 
-#[experimental = "needs review"]
+#[experimental = "trait is experimental"]
 impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -1256,7 +1257,7 @@ pub struct ChunksMut<'a, T:'a> {
     chunk_size: uint
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> Iterator for ChunksMut<'a, T> {
     type Item = &'a mut [T];
 
@@ -1286,7 +1287,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut [T]> {

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index d069744f8da54f109bba4c957240999bbbfa8258..a3c6a3fe470c3096c3905791e34b15b38318149a 100644 (file)
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -37,11 +37,8 @@
 macro_rules! delegate_iter {
     (exact $te:ty in $ti:ty) => {
         delegate_iter!{$te in $ti}
+        #[stable]
         impl<'a> ExactSizeIterator for $ti {
-            #[inline]
-            fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
-                self.0.rposition(predicate)
-            }
             #[inline]
             fn len(&self) -> uint {
                 self.0.len()
@@ -49,6 +46,7 @@ fn len(&self) -> uint {
         }
     };
     ($te:ty in $ti:ty) => {
+        #[stable]
         impl<'a> Iterator for $ti {
             type Item = $te;
 
@@ -61,6 +59,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
                 self.0.size_hint()
             }
         }
+        #[stable]
         impl<'a> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
@@ -69,6 +68,7 @@ fn next_back(&mut self) -> Option<$te> {
         }
     };
     (pattern $te:ty in $ti:ty) => {
+        #[stable]
         impl<'a, P: CharEq> Iterator for $ti {
             type Item = $te;
 
@@ -81,6 +81,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
                 self.0.size_hint()
             }
         }
+        #[stable]
         impl<'a, P: CharEq> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
@@ -89,6 +90,7 @@ fn next_back(&mut self) -> Option<$te> {
         }
     };
     (pattern forward $te:ty in $ti:ty) => {
+        #[stable]
         impl<'a, P: CharEq> Iterator for $ti {
             type Item = $te;
 
@@ -275,6 +277,7 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
     }
 }
 
+#[stable]
 impl<'a> Iterator for Chars<'a> {
     type Item = char;
 
@@ -320,6 +323,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<'a> DoubleEndedIterator for Chars<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
@@ -356,11 +360,13 @@ fn next_back(&mut self) -> Option<char> {
 /// External iterator for a string's characters and their byte offsets.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[stable]
 pub struct CharIndices<'a> {
     front_offset: uint,
     iter: Chars<'a>,
 }
 
+#[stable]
 impl<'a> Iterator for CharIndices<'a> {
     type Item = (uint, char);
 
@@ -384,6 +390,7 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
+#[stable]
 impl<'a> DoubleEndedIterator for CharIndices<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<(uint, char)> {
@@ -465,6 +472,7 @@ fn get_end(&mut self) -> Option<&'a str> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
     type Item = &'a str;
 
@@ -499,6 +507,7 @@ fn next(&mut self) -> Option<&'a str> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> {
@@ -540,6 +549,7 @@ fn next_back(&mut self) -> Option<&'a str> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
     type Item = &'a str;
 
@@ -865,6 +875,7 @@ pub struct SplitStr<'a> {
     finished: bool
 }
 
+#[stable]
 impl<'a> Iterator for MatchIndices<'a> {
     type Item = (uint, uint);
 
@@ -881,6 +892,7 @@ fn next(&mut self) -> Option<(uint, uint)> {
     }
 }
 
+#[stable]
 impl<'a> Iterator for SplitStr<'a> {
     type Item = &'a str;
 
@@ -1586,6 +1598,7 @@ impl<'a> Default for &'a str {
     fn default() -> &'a str { "" }
 }
 
+#[stable]
 impl<'a> Iterator for Lines<'a> {
     type Item = &'a str;
 
@@ -1593,11 +1606,13 @@ impl<'a> Iterator for Lines<'a> {
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
-}
+
+#[stable]}
 impl<'a> DoubleEndedIterator for Lines<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
-}
+
+#[stable]}
 impl<'a> Iterator for LinesAny<'a> {
     type Item = &'a str;
 
@@ -1605,7 +1620,8 @@ impl<'a> Iterator for LinesAny<'a> {
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
-}
+
+#[stable]}
 impl<'a> DoubleEndedIterator for LinesAny<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }

diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index b1824db93aad120faec507751c130125ad431919..c44d6c34cd94608a365398acca31aee454e86d8d 100644 (file)
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -18,7 +18,7 @@
 use fmt::Show;
 use fmt;
 use hash::{Hash, Hasher, RandomSipHasher};
-use iter::{Iterator, IteratorExt, IteratorCloneExt, FromIterator, Map, Chain, Extend};
+use iter::{Iterator, IteratorExt, FromIterator, Map, Chain, Extend};
 use ops::{BitOr, BitAnd, BitXor, Sub};
 use option::Option::{Some, None, self};
 use result::Result::{Ok, Err};

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index c56acd38e810f2f89c380c58af5948ce4f02c4d0..c4e37264e2aeeb2d3ff1a83d58be901a2cc8e24a 100644 (file)
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -14,7 +14,7 @@
 
 use cmp;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
-use iter::ExactSizeIterator;
+use iter::{IteratorExt, ExactSizeIterator};
 use ops::Drop;
 use option::Option;
 use option::Option::{Some, None};

diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index f6bdcd53dff24c29dd68528d1f45ebbb427e051f..9e9a483e1a5e3f510922eb6ae9b652eda2848162 100644 (file)
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -25,11 +25,9 @@
 #[stable] #[doc(no_inline)] pub use char::CharExt;
 #[stable] #[doc(no_inline)] pub use clone::Clone;
 #[stable] #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
-#[stable] #[doc(no_inline)] pub use iter::CloneIteratorExt;
 #[stable] #[doc(no_inline)] pub use iter::DoubleEndedIterator;
 #[stable] #[doc(no_inline)] pub use iter::ExactSizeIterator;
 #[stable] #[doc(no_inline)] pub use iter::{Iterator, IteratorExt, Extend};
-#[stable] #[doc(no_inline)] pub use iter::{IteratorCloneExt, IteratorOrdExt};
 #[stable] #[doc(no_inline)] pub use option::Option::{self, Some, None};
 #[stable] #[doc(no_inline)] pub use ptr::{PtrExt, MutPtrExt};
 #[stable] #[doc(no_inline)] pub use result::Result::{self, Ok, Err};

diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs
index 7734f655ed2936c5f1cc3be2f646e906ca7b97a6..e97be51fdbc25af6ccc56aec377ee00aee43173a 100644 (file)
--- a/src/libstd/sync/condvar.rs
+++ b/src/libstd/sync/condvar.rs
@@ -188,6 +188,7 @@ pub fn notify_one(&self) { unsafe { self.inner.inner.notify_one() } }
     pub fn notify_all(&self) { unsafe { self.inner.inner.notify_all() } }
 }
 
+#[stable]
 impl Drop for Condvar {
     fn drop(&mut self) {
         unsafe { self.inner.inner.destroy() }

diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 6bc3f561bb3c74a967316e06815507bf8413d874..09ff8f440f33ea6c492f69c8045b00224148ce11 100644 (file)
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -657,6 +657,7 @@ fn clone(&self) -> Sender<T> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for Sender<T> {
     fn drop(&mut self) {
         match *unsafe { self.inner_mut() } {
@@ -720,6 +721,7 @@ fn clone(&self) -> SyncSender<T> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for SyncSender<T> {
     fn drop(&mut self) {
         unsafe { (*self.inner.get()).drop_chan(); }
@@ -935,7 +937,7 @@ fn abort_selection(&self) -> bool {
     }
 }
 
-#[unstable]
+#[stable]
 impl<'a, T: Send> Iterator for Iter<'a, T> {
     type Item = T;
 
@@ -943,6 +945,7 @@ fn next(&mut self) -> Option<T> { self.rx.recv().ok() }
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for Receiver<T> {
     fn drop(&mut self) {
         match *unsafe { self.inner_mut() } {

diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index 8f85dc6e043e20de7bc859204ece37fac4f5553b..9ad24a5a11ec5dfb61080a507b4d4a61920a8198 100644 (file)
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -138,6 +138,7 @@ pub fn pop(&self) -> PopResult<T> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for Queue<T> {
     fn drop(&mut self) {
         unsafe {

diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index b158bd69c7b506addc9ecd1df5fdf4d8e82a58ea..6b3dd89f33b07fcc71cc4a4a02cdfd7c4072ec2a 100644 (file)
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -228,6 +228,7 @@ pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for Mutex<T> {
     fn drop(&mut self) {
         // This is actually safe b/c we know that there is no further usage of
@@ -291,6 +292,7 @@ fn new(lock: &'mutex StaticMutex, data: &'mutex UnsafeCell<T>)
     }
 }
 
+#[stable]
 impl<'mutex, T> Deref for MutexGuard<'mutex, T> {
     type Target = T;
 
@@ -298,6 +300,7 @@ fn deref<'a>(&'a self) -> &'a T {
         unsafe { &*self.__data.get() }
     }
 }
+#[stable]
 impl<'mutex, T> DerefMut for MutexGuard<'mutex, T> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut T {
         unsafe { &mut *self.__data.get() }
@@ -305,6 +308,7 @@ fn deref_mut<'a>(&'a mut self) -> &'a mut T {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<'a, T> Drop for MutexGuard<'a, T> {
     #[inline]
     fn drop(&mut self) {

diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index b2367ff8352fbb8d30f62b7f59080b93eb3bd9cb..c8ca1b02aab1a29256aa756b03e4138fa7e11a9c 100644 (file)
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -228,6 +228,7 @@ pub fn try_write(&self) -> TryLockResult<RWLockWriteGuard<T>> {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T> Drop for RWLock<T> {
     fn drop(&mut self) {
         unsafe { self.inner.lock.destroy() }
@@ -327,16 +328,19 @@ fn new(lock: &'rwlock StaticRWLock, data: &'rwlock UnsafeCell<T>)
     }
 }
 
+#[stable]
 impl<'rwlock, T> Deref for RWLockReadGuard<'rwlock, T> {
     type Target = T;
 
     fn deref(&self) -> &T { unsafe { &*self.__data.get() } }
 }
+#[stable]
 impl<'rwlock, T> Deref for RWLockWriteGuard<'rwlock, T> {
     type Target = T;
 
     fn deref(&self) -> &T { unsafe { &*self.__data.get() } }
 }
+#[stable]
 impl<'rwlock, T> DerefMut for RWLockWriteGuard<'rwlock, T> {
     fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.__data.get() }
@@ -344,6 +348,7 @@ fn deref_mut(&mut self) -> &mut T {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<'a, T> Drop for RWLockReadGuard<'a, T> {
     fn drop(&mut self) {
         unsafe { self.__lock.lock.read_unlock(); }
@@ -351,6 +356,7 @@ fn drop(&mut self) {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<'a, T> Drop for RWLockWriteGuard<'a, T> {
     fn drop(&mut self) {
         self.__lock.poison.done(&self.__poison);

diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs
index c0ff674ba0f7dad5870d64df1f644bac1ceb3a53..505819fbf8a246cf4ee618b64e89cb921dd8d8a7 100644 (file)
--- a/src/libstd/sync/semaphore.rs
+++ b/src/libstd/sync/semaphore.rs
@@ -99,6 +99,7 @@ pub fn access(&self) -> SemaphoreGuard {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<'a> Drop for SemaphoreGuard<'a> {
     fn drop(&mut self) {
         self.sem.release();

diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index 63112327415d238e50f0e95c46f28ed73666b4b2..cc82d38ae2af1f01140701dd4e6894296fc594d6 100644 (file)
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -423,6 +423,7 @@ pub fn detach(mut self) {
 }
 
 #[unsafe_destructor]
+#[stable]
 impl<T: Send> Drop for JoinGuard<T> {
     fn drop(&mut self) {
         if !self.joined {