std: fix fallout

diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index b1433ad7fdc625d249da00d8e076177b9153c576..834a9f082d03a5bd24be835120bf53f45231a467 100644 (file)
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -504,7 +504,9 @@ pub struct CChars<'a> {
     marker: marker::ContravariantLifetime<'a>,
 }
 
-impl<'a> Iterator<libc::c_char> for CChars<'a> {
+impl<'a> Iterator for CChars<'a> {
+    type Item = libc::c_char;
+
     fn next(&mut self) -> Option<libc::c_char> {
         let ch = unsafe { *self.ptr };
         if ch == 0 {

diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index d4fc4150fae9143877fa8e772875fb9e976215f9..6450b149d0242a961a5f66192986eca818aecce9 100644 (file)
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -1423,37 +1423,49 @@ enum VacantEntryState<K, V, M> {
 }
 
 #[stable]
-impl<'a, K, V> Iterator<(&'a K, &'a V)> for Iter<'a, K, V> {
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
     #[inline] fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
 #[stable]
-impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for IterMut<'a, K, V> {
+impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+    type Item = (&'a K, &'a mut V);
+
     #[inline] fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
 #[stable]
-impl<K, V> Iterator<(K, V)> for IntoIter<K, V> {
+impl<K, V> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
     #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
 #[stable]
-impl<'a, K, V> Iterator<&'a K> for Keys<'a, K, V> {
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+    type Item = &'a K;
+
     #[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
 #[stable]
-impl<'a, K, V> Iterator<&'a V> for Values<'a, K, V> {
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+    type Item = &'a V;
+
     #[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
 #[stable]
-impl<'a, K: 'a, V: 'a> Iterator<(K, V)> for Drain<'a, K, V> {
+impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
+    type Item = (K, V);
+
     #[inline]
     fn next(&mut self) -> Option<(K, V)> {
         self.inner.next()
@@ -1511,7 +1523,7 @@ pub fn set(self, value: V) -> &'a mut V {
 
 #[stable]
 impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
-    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {
+    fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, H> {
         let lower = iter.size_hint().0;
         let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
         map.extend(iter);
@@ -1521,7 +1533,7 @@ fn from_iter<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {
 
 #[stable]
 impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Extend<(K, V)> for HashMap<K, V, H> {
-    fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
+    fn extend<T: Iterator<Item=(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {
             self.insert(k, v);
         }

diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 6132d288da2799ca4698acf467c3ab6db7cb935e..ea8298c48c83f11231b2485a9368f6d0dd003a96 100644 (file)
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -603,7 +603,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
 #[stable]
 impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
-    fn from_iter<I: Iterator<T>>(iter: I) -> HashSet<T, H> {
+    fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, H> {
         let lower = iter.size_hint().0;
         let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());
         set.extend(iter);
@@ -613,7 +613,7 @@ fn from_iter<I: Iterator<T>>(iter: I) -> HashSet<T, H> {
 
 #[stable]
 impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> Extend<T> for HashSet<T, H> {
-    fn extend<I: Iterator<T>>(&mut self, mut iter: I) {
+    fn extend<I: Iterator<Item=T>>(&mut self, mut iter: I) {
         for k in iter {
             self.insert(k);
         }
@@ -789,27 +789,35 @@ pub struct Union<'a, T: 'a, H: 'a> {
 }
 
 #[stable]
-impl<'a, K> Iterator<&'a K> for Iter<'a, K> {
+impl<'a, K> Iterator for Iter<'a, K> {
+    type Item = &'a K;
+
     fn next(&mut self) -> Option<&'a K> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[stable]
-impl<K> Iterator<K> for IntoIter<K> {
+impl<K> Iterator for IntoIter<K> {
+    type Item = K;
+
     fn next(&mut self) -> Option<K> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[stable]
-impl<'a, K: 'a> Iterator<K> for Drain<'a, K> {
+impl<'a, K: 'a> Iterator for Drain<'a, K> {
+    type Item = K;
+
     fn next(&mut self) -> Option<K> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[stable]
-impl<'a, T, S, H> Iterator<&'a T> for Intersection<'a, T, H>
+impl<'a, T, S, H> Iterator for Intersection<'a, T, H>
     where T: Eq + Hash<S>, H: Hasher<S>
 {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             match self.iter.next() {
@@ -828,9 +836,11 @@ fn size_hint(&self) -> (uint, Option<uint>) {
 }
 
 #[stable]
-impl<'a, T, S, H> Iterator<&'a T> for Difference<'a, T, H>
+impl<'a, T, S, H> Iterator for Difference<'a, T, H>
     where T: Eq + Hash<S>, H: Hasher<S>
 {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             match self.iter.next() {
@@ -849,17 +859,21 @@ fn size_hint(&self) -> (uint, Option<uint>) {
 }
 
 #[stable]
-impl<'a, T, S, H> Iterator<&'a T> for SymmetricDifference<'a, T, H>
+impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H>
     where T: Eq + Hash<S>, H: Hasher<S>
 {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[stable]
-impl<'a, T, S, H> Iterator<&'a T> for Union<'a, T, H>
+impl<'a, T, S, H> Iterator for Union<'a, T, H>
     where T: Eq + Hash<S>, H: Hasher<S>
 {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }

diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index a687ba3da8d7fc648936c4203aa8819413415867..2b999d83a98c284e5d492aab06ec2a89e8ffe52a 100644 (file)
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -730,7 +730,9 @@ fn clone(&self) -> RawBuckets<'a, K, V> {
 }
 
 
-impl<'a, K, V> Iterator<RawBucket<K, V>> for RawBuckets<'a, K, V> {
+impl<'a, K, V> Iterator for RawBuckets<'a, K, V> {
+    type Item = RawBucket<K, V>;
+
     fn next(&mut self) -> Option<RawBucket<K, V>> {
         while self.raw.hash != self.hashes_end {
             unsafe {
@@ -757,7 +759,9 @@ struct RevMoveBuckets<'a, K, V> {
     marker: marker::ContravariantLifetime<'a>,
 }
 
-impl<'a, K, V> Iterator<(K, V)> for RevMoveBuckets<'a, K, V> {
+impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> {
+    type Item = (K, V);
+
     fn next(&mut self) -> Option<(K, V)> {
         if self.elems_left == 0 {
             return None;
@@ -816,7 +820,9 @@ pub struct Drain<'a, K: 'a, V: 'a> {
     iter: RawBuckets<'static, K, V>,
 }
 
-impl<'a, K, V> Iterator<(&'a K, &'a V)> for Iter<'a, K, V> {
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
     fn next(&mut self) -> Option<(&'a K, &'a V)> {
         self.iter.next().map(|bucket| {
             self.elems_left -= 1;
@@ -832,7 +838,9 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for IterMut<'a, K, V> {
+impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+    type Item = (&'a K, &'a mut V);
+
     fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
         self.iter.next().map(|bucket| {
             self.elems_left -= 1;
@@ -848,7 +856,9 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-impl<K, V> Iterator<(SafeHash, K, V)> for IntoIter<K, V> {
+impl<K, V> Iterator for IntoIter<K, V> {
+    type Item = (SafeHash, K, V);
+
     fn next(&mut self) -> Option<(SafeHash, K, V)> {
         self.iter.next().map(|bucket| {
             self.table.size -= 1;
@@ -870,7 +880,9 @@ fn size_hint(&self) -> (uint, Option<uint>) {
     }
 }
 
-impl<'a, K: 'a, V: 'a> Iterator<(SafeHash, K, V)> for Drain<'a, K, V> {
+impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
+    type Item = (SafeHash, K, V);
+
     #[inline]
     fn next(&mut self) -> Option<(SafeHash, K, V)> {
         self.iter.next().map(|bucket| {

diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 94dba1f7cc70a1f539d7e78f783ce5b7afb149e1..8c097a65db7bd45d51aa739567dc22812c982d30 100644 (file)
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -52,7 +52,9 @@ pub fn new(r: &'r mut R) -> Bytes<'r, R> {
     }
 }
 
-impl<'r, R: Reader> Iterator<IoResult<u8>> for Bytes<'r, R> {
+impl<'r, R: Reader> Iterator for Bytes<'r, R> {
+    type Item = IoResult<u8>;
+
     #[inline]
     fn next(&mut self) -> Option<IoResult<u8>> {
         match self.reader.read_byte() {

diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 7fa5b3cfac7e254e2c4cd5075a3653dd2ab3efed..1ff54fcb4843201f471da952e485debd793c13c4 100644 (file)
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -563,7 +563,9 @@ pub struct Directories {
     stack: Vec<Path>,
 }
 
-impl Iterator<Path> for Directories {
+impl Iterator for Directories {
+    type Item = Path;
+
     fn next(&mut self) -> Option<Path> {
         match self.stack.pop() {
             Some(path) => {

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 0a7815aeb53671ccbaf7878012f51a1a2bf408ce..4c9c7beb475017fbb5b5600a643a9d9feda2b22d 100644 (file)
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1371,7 +1371,9 @@ pub struct Lines<'r, T:'r> {
     buffer: &'r mut T,
 }
 
-impl<'r, T: Buffer> Iterator<IoResult<String>> for Lines<'r, T> {
+impl<'r, T: Buffer> Iterator for Lines<'r, T> {
+    type Item = IoResult<String>;
+
     fn next(&mut self) -> Option<IoResult<String>> {
         match self.buffer.read_line() {
             Ok(x) => Some(Ok(x)),
@@ -1398,7 +1400,9 @@ pub struct Chars<'r, T:'r> {
     buffer: &'r mut T
 }
 
-impl<'r, T: Buffer> Iterator<IoResult<char>> for Chars<'r, T> {
+impl<'r, T: Buffer> Iterator for Chars<'r, T> {
+    type Item = IoResult<char>;
+
     fn next(&mut self) -> Option<IoResult<char>> {
         match self.buffer.read_char() {
             Ok(x) => Some(Ok(x)),
@@ -1649,14 +1653,18 @@ pub struct IncomingConnections<'a, Sized? A:'a> {
 }
 
 #[cfg(stage0)]
-impl<'a, T, A: Acceptor<T>> Iterator<IoResult<T>> for IncomingConnections<'a, A> {
+impl<'a, T, A: Acceptor<T>> Iterator for IncomingConnections<'a, A> {
+    type Item = IoResult<T>;
+
     fn next(&mut self) -> Option<IoResult<T>> {
         Some(self.inc.accept())
     }
 }
 
 #[cfg(not(stage0))]
-impl<'a, T, Sized? A: Acceptor<T>> Iterator<IoResult<T>> for IncomingConnections<'a, A> {
+impl<'a, T, Sized? A: Acceptor<T>> Iterator for IncomingConnections<'a, A> {
+    type Item = IoResult<T>;
+
     fn next(&mut self) -> Option<IoResult<T>> {
         Some(self.inc.accept())
     }

diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 38ab71c172c59ea710c7b9a68b545dd78c7e3f13..51d1bacf63b9f28b2a0a61fb2b2ee230835b862f 100644 (file)
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -169,7 +169,7 @@ pub struct ChainedReader<I, R> {
     cur_reader: Option<R>,
 }
 
-impl<R: Reader, I: Iterator<R>> ChainedReader<I, R> {
+impl<R: Reader, I: Iterator<Item=R>> ChainedReader<I, R> {
     /// Creates a new `ChainedReader`
     pub fn new(mut readers: I) -> ChainedReader<I, R> {
         let r = readers.next();
@@ -177,7 +177,7 @@ pub fn new(mut readers: I) -> ChainedReader<I, R> {
     }
 }
 
-impl<R: Reader, I: Iterator<R>> Reader for ChainedReader<I, R> {
+impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         loop {
             let err = match self.cur_reader {
@@ -252,7 +252,7 @@ pub struct IterReader<T> {
     iter: T,
 }
 
-impl<T: Iterator<u8>> IterReader<T> {
+impl<T: Iterator<Item=u8>> IterReader<T> {
     /// Creates a new `IterReader` which will read from the specified
     /// `Iterator`.
     pub fn new(iter: T) -> IterReader<T> {
@@ -260,7 +260,7 @@ pub fn new(iter: T) -> IterReader<T> {
     }
 }
 
-impl<T: Iterator<u8>> Reader for IterReader<T> {
+impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         let mut len = 0;

diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 86b8bfc73709d6998f722d098b85fb3cf36752cc..208e4f9e566f42ec74f4ced40517519e91338ed2 100644 (file)
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -404,7 +404,7 @@ pub fn random<T: Rand>() -> T {
 /// let sample = sample(&mut rng, range(1i, 100), 5);
 /// println!("{}", sample);
 /// ```
-pub fn sample<T, I: Iterator<T>, R: Rng>(rng: &mut R,
+pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R,
                                          mut iter: I,
                                          amount: uint) -> Vec<T> {
     let mut reservoir: Vec<T> = iter.by_ref().take(amount).collect();

diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 413675f26d59c96e39471d6624fff38497e22c66..e9dc3d986ba115940a9b4a521a37f772cddb2885 100644 (file)
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -936,7 +936,9 @@ fn abort_selection(&self) -> bool {
 }
 
 #[unstable]
-impl<'a, T: Send> Iterator<T> for Iter<'a, T> {
+impl<'a, T: Send> Iterator for Iter<'a, T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> { self.rx.recv().ok() }
 }
 

diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 43554d7c335a4c4471084162593651789fcc2c64..3d9dca7e21cb3d499b0903fe9416e27d1932e303 100644 (file)
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -319,7 +319,9 @@ fn drop(&mut self) {
     }
 }
 
-impl Iterator<*mut Handle<'static, ()>> for Packets {
+impl Iterator for Packets {
+    type Item = *mut Handle<'static, ()>;
+
     fn next(&mut self) -> Option<*mut Handle<'static, ()>> {
         if self.cur.is_null() {
             None