diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
index f748c8ad1eb2a..da461ae2d4d53 100644
--- a/src/libcollections/binary_heap.rs
+++ b/src/libcollections/binary_heap.rs
@@ -573,7 +573,9 @@ impl<'a, T> Clone for Iter<'a, T> {
 }
 
 #[stable]
-impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
     #[inline]
     fn next(&mut self) -> Option<&'a T> { self.iter.next() }
 
@@ -582,13 +584,13 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
 }
 
 #[stable]
-impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a T> { self.iter.next_back() }
 }
 
 #[stable]
-impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 /// An iterator that moves out of a `BinaryHeap`.
 pub struct IntoIter<T> {
@@ -596,7 +598,9 @@ pub struct IntoIter<T> {
 }
 
 #[stable]
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> { self.iter.next() }
 
@@ -605,13 +609,13 @@ impl<T> Iterator<T> for IntoIter<T> {
 }
 
 #[stable]
-impl<T> DoubleEndedIterator<T> for IntoIter<T> {
+impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
 }
 
 #[stable]
-impl<T> ExactSizeIterator<T> for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// An iterator that drains a `BinaryHeap`.
 pub struct Drain<'a, T: 'a> {
@@ -619,7 +623,9 @@ pub struct Drain<'a, T: 'a> {
 }
 
 #[stable]
-impl<'a, T: 'a> Iterator<T> for Drain<'a, T> {
+impl<'a, T: 'a> Iterator for Drain<'a, T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> { self.iter.next() }
 
@@ -628,24 +634,24 @@ impl<'a, T: 'a> Iterator<T> for Drain<'a, T> {
 }
 
 #[stable]
-impl<'a, T: 'a> DoubleEndedIterator<T> for Drain<'a, T> {
+impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
 }
 
 #[stable]
-impl<'a, T: 'a> ExactSizeIterator<T> for Drain<'a, T> {}
+impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
 
 #[stable]
 impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
-    fn from_iter<Iter: Iterator<T>>(iter: Iter) -> BinaryHeap<T> {
+    fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BinaryHeap<T> {
         BinaryHeap::from_vec(iter.collect())
     }
 }
 
 #[stable]
 impl<T: Ord> Extend<T> for BinaryHeap<T> {
-    fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
+    fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 
         self.reserve(lower);
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index a5b8c5f3e5718..5c52223bccd13 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -938,7 +938,7 @@ impl Default for Bitv {
 
 #[stable]
 impl FromIterator<bool> for Bitv {
-    fn from_iter<I:Iterator<bool>>(iterator: I) -> Bitv {
+    fn from_iter<I:Iterator<Item=bool>>(iterator: I) -> Bitv {
         let mut ret = Bitv::new();
         ret.extend(iterator);
         ret
@@ -948,7 +948,7 @@ impl FromIterator<bool> for Bitv {
 #[stable]
 impl Extend<bool> for Bitv {
     #[inline]
-    fn extend<I: Iterator<bool>>(&mut self, mut iterator: I) {
+    fn extend<I: Iterator<Item=bool>>(&mut self, mut iterator: I) {
         let (min, _) = iterator.size_hint();
         self.reserve(min);
         for element in iterator {
@@ -1031,7 +1031,9 @@ pub struct Iter<'a> {
 }
 
 #[stable]
-impl<'a> Iterator<bool> for Iter<'a> {
+impl<'a> Iterator for Iter<'a> {
+    type Item = bool;
+
     #[inline]
     fn next(&mut self) -> Option<bool> {
         if self.next_idx != self.end_idx {
@@ -1050,7 +1052,7 @@ impl<'a> Iterator<bool> for Iter<'a> {
 }
 
 #[stable]
-impl<'a> DoubleEndedIterator<bool> for Iter<'a> {
+impl<'a> DoubleEndedIterator for Iter<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<bool> {
         if self.next_idx != self.end_idx {
@@ -1063,10 +1065,10 @@ impl<'a> DoubleEndedIterator<bool> for Iter<'a> {
 }
 
 #[stable]
-impl<'a> ExactSizeIterator<bool> for Iter<'a> {}
+impl<'a> ExactSizeIterator for Iter<'a> {}
 
 #[stable]
-impl<'a> RandomAccessIterator<bool> for Iter<'a> {
+impl<'a> RandomAccessIterator for Iter<'a> {
     #[inline]
     fn indexable(&self) -> uint {
         self.end_idx - self.next_idx
@@ -1134,7 +1136,7 @@ impl Default for BitvSet {
 
 #[stable]
 impl FromIterator<uint> for BitvSet {
-    fn from_iter<I:Iterator<uint>>(iterator: I) -> BitvSet {
+    fn from_iter<I:Iterator<Item=uint>>(iterator: I) -> BitvSet {
         let mut ret = BitvSet::new();
         ret.extend(iterator);
         ret
@@ -1144,7 +1146,7 @@ impl FromIterator<uint> for BitvSet {
 #[stable]
 impl Extend<uint> for BitvSet {
     #[inline]
-    fn extend<I: Iterator<uint>>(&mut self, mut iterator: I) {
+    fn extend<I: Iterator<Item=uint>>(&mut self, mut iterator: I) {
         for i in iterator {
             self.insert(i);
         }
@@ -1792,7 +1794,9 @@ pub struct Difference<'a>(TwoBitPositions<'a>);
 pub struct SymmetricDifference<'a>(TwoBitPositions<'a>);
 
 #[stable]
-impl<'a> Iterator<uint> for SetIter<'a> {
+impl<'a> Iterator for SetIter<'a> {
+    type Item = uint;
+
     fn next(&mut self) -> Option<uint> {
         while self.next_idx < self.set.bitv.len() {
             let idx = self.next_idx;
@@ -1813,7 +1817,9 @@ impl<'a> Iterator<uint> for SetIter<'a> {
 }
 
 #[stable]
-impl<'a> Iterator<uint> for TwoBitPositions<'a> {
+impl<'a> Iterator for TwoBitPositions<'a> {
+    type Item = uint;
+
     fn next(&mut self) -> Option<uint> {
         while self.next_idx < self.set.bitv.len() ||
               self.next_idx < self.other.bitv.len() {
@@ -1849,25 +1855,33 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
 }
 
 #[stable]
-impl<'a> Iterator<uint> for Union<'a> {
+impl<'a> Iterator for Union<'a> {
+    type Item = uint;
+
     #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
 
 #[stable]
-impl<'a> Iterator<uint> for Intersection<'a> {
+impl<'a> Iterator for Intersection<'a> {
+    type Item = uint;
+
     #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
 
 #[stable]
-impl<'a> Iterator<uint> for Difference<'a> {
+impl<'a> Iterator for Difference<'a> {
+    type Item = uint;
+
     #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
 
 #[stable]
-impl<'a> Iterator<uint> for SymmetricDifference<'a> {
+impl<'a> Iterator for SymmetricDifference<'a> {
+    type Item = uint;
+
     #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index da98c19e888fa..1317889372308 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -823,7 +823,7 @@ mod stack {
 
 #[stable]
 impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
-    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> BTreeMap<K, V> {
+    fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> BTreeMap<K, V> {
         let mut map = BTreeMap::new();
         map.extend(iter);
         map
@@ -833,7 +833,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
 #[stable]
 impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
     #[inline]
-    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);
         }
@@ -949,8 +949,11 @@ enum StackOp<T> {
     Pop,
 }
 
-impl<K, V, E, T: Traverse<E> + DoubleEndedIterator<TraversalItem<K, V, E>>>
-        Iterator<(K, V)> for AbsIter<T> {
+impl<K, V, E, T> Iterator for AbsIter<T> where
+    T: DoubleEndedIterator + Iterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
+{
+    type Item = (K, V);
+
     // This function is pretty long, but only because there's a lot of cases to consider.
     // Our iterator represents two search paths, left and right, to the smallest and largest
     // elements we have yet to yield. lca represents the least common ancestor of these two paths,
@@ -1015,8 +1018,9 @@ impl<K, V, E, T: Traverse<E> + DoubleEndedIterator<TraversalItem<K, V, E>>>
     }
 }
 
-impl<K, V, E, T: Traverse<E> + DoubleEndedIterator<TraversalItem<K, V, E>>>
-        DoubleEndedIterator<(K, V)> for AbsIter<T> {
+impl<K, V, E, T> DoubleEndedIterator for AbsIter<T> where
+    T: DoubleEndedIterator + Iterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
+{
     // next_back is totally symmetric to next
     fn next_back(&mut self) -> Option<(K, V)> {
         loop {
@@ -1054,64 +1058,75 @@ impl<K, V, E, T: Traverse<E> + DoubleEndedIterator<TraversalItem<K, V, E>>>
 }
 
 #[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);
+
     fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 #[stable]
-impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a V)> for Iter<'a, K, V> {
+impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
     fn next_back(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next_back() }
 }
 #[stable]
-impl<'a, K, V> ExactSizeIterator<(&'a K, &'a V)> for Iter<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {}
 
 #[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);
+
     fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 #[stable]
-impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a mut V)> for IterMut<'a, K, V> {
+impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
     fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next_back() }
 }
 #[stable]
-impl<'a, K, V> ExactSizeIterator<(&'a K, &'a mut V)> for IterMut<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {}
 
 #[stable]
-impl<K, V> Iterator<(K, V)> for IntoIter<K, V> {
+impl<K, V> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
     fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 #[stable]
-impl<K, V> DoubleEndedIterator<(K, V)> for IntoIter<K, V> {
+impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
     fn next_back(&mut self) -> Option<(K, V)> { self.inner.next_back() }
 }
 #[stable]
-impl<K, V> ExactSizeIterator<(K, V)> for IntoIter<K, V> {}
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {}
 
 #[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;
+
     fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 #[stable]
-impl<'a, K, V> DoubleEndedIterator<&'a K> for Keys<'a, K, V> {
+impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
     fn next_back(&mut self) -> Option<(&'a K)> { self.inner.next_back() }
 }
 #[stable]
-impl<'a, K, V> ExactSizeIterator<&'a K> for Keys<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
+
 
 #[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;
+
     fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 #[stable]
-impl<'a, K, V> DoubleEndedIterator<&'a V> for Values<'a, K, V> {
+impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
     fn next_back(&mut self) -> Option<(&'a V)> { self.inner.next_back() }
 }
 #[stable]
-impl<'a, K, V> ExactSizeIterator<&'a V> for Values<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
 
 
 impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs
index 3dddcae11ce7c..f50650c2c8be3 100644
--- a/src/libcollections/btree/node.rs
+++ b/src/libcollections/btree/node.rs
@@ -210,7 +210,9 @@ impl<T> RawItems<T> {
     }
 }
 
-impl<T> Iterator<T> for RawItems<T> {
+impl<T> Iterator for RawItems<T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         if self.head == self.tail {
             None
@@ -230,7 +232,7 @@ impl<T> Iterator<T> for RawItems<T> {
     }
 }
 
-impl<T> DoubleEndedIterator<T> for RawItems<T> {
+impl<T> DoubleEndedIterator for RawItems<T> {
     fn next_back(&mut self) -> Option<T> {
         if self.head == self.tail {
             None
@@ -1321,8 +1323,10 @@ trait TraversalImpl<K, V, E> {
 /// as no deallocation needs to be done.
 struct ElemsAndEdges<Elems, Edges>(Elems, Edges);
 
-impl<K, V, E, Elems: DoubleEndedIterator<(K, V)>, Edges: DoubleEndedIterator<E>>
-        TraversalImpl<K, V, E> for ElemsAndEdges<Elems, Edges> {
+impl<K, V, E, Elems: DoubleEndedIterator, Edges: DoubleEndedIterator>
+        TraversalImpl<K, V, E> for ElemsAndEdges<Elems, Edges>
+    where Elems : Iterator<Item=(K, V)>, Edges : Iterator<Item=E>
+{
 
     fn next_kv(&mut self) -> Option<(K, V)> { self.0.next() }
     fn next_kv_back(&mut self) -> Option<(K, V)> { self.0.next_back() }
@@ -1414,8 +1418,8 @@ pub type MutTraversal<'a, K, V> = AbsTraversal<ElemsAndEdges<Zip<slice::Iter<'a,
 pub type MoveTraversal<K, V> = AbsTraversal<MoveTraversalImpl<K, V>>;
 
 
-impl<K, V, E, Impl: TraversalImpl<K, V, E>>
-        Iterator<TraversalItem<K, V, E>> for AbsTraversal<Impl> {
+impl<K, V, E, Impl: TraversalImpl<K, V, E>> Iterator for AbsTraversal<Impl> {
+    type Item = TraversalItem<K, V, E>;
 
     fn next(&mut self) -> Option<TraversalItem<K, V, E>> {
         let head_is_edge = self.head_is_edge;
@@ -1429,9 +1433,7 @@ impl<K, V, E, Impl: TraversalImpl<K, V, E>>
     }
 }
 
-impl<K, V, E, Impl: TraversalImpl<K, V, E>>
-        DoubleEndedIterator<TraversalItem<K, V, E>> for AbsTraversal<Impl> {
-
+impl<K, V, E, Impl: TraversalImpl<K, V, E>> DoubleEndedIterator for AbsTraversal<Impl> {
     fn next_back(&mut self) -> Option<TraversalItem<K, V, E>> {
         let tail_is_edge = self.tail_is_edge;
         self.tail_is_edge = !tail_is_edge;
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
index 3e8988530e63e..6512243ed1a17 100644
--- a/src/libcollections/btree/set.rs
+++ b/src/libcollections/btree/set.rs
@@ -436,7 +436,7 @@ impl<T: Ord> BTreeSet<T> {
 
 #[stable]
 impl<T: Ord> FromIterator<T> for BTreeSet<T> {
-    fn from_iter<Iter: Iterator<T>>(iter: Iter) -> BTreeSet<T> {
+    fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BTreeSet<T> {
         let mut set = BTreeSet::new();
         set.extend(iter);
         set
@@ -446,7 +446,7 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
 #[stable]
 impl<T: Ord> Extend<T> for BTreeSet<T> {
     #[inline]
-    fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
+    fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {
         for elem in iter {
             self.insert(elem);
         }
@@ -560,28 +560,33 @@ impl<T: Show> Show for BTreeSet<T> {
 }
 
 #[stable]
-impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
+impl<'a, T> Iterator for Iter<'a, T> {
+    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> DoubleEndedIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     fn next_back(&mut self) -> Option<&'a T> { self.iter.next_back() }
 }
 #[stable]
-impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+
 
 #[stable]
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 #[stable]
-impl<T> DoubleEndedIterator<T> for IntoIter<T> {
+impl<T> DoubleEndedIterator for IntoIter<T> {
     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
 }
 #[stable]
-impl<T> ExactSizeIterator<T> for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
 fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
@@ -594,7 +599,9 @@ fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
 }
 
 #[stable]
-impl<'a, T: Ord> Iterator<&'a T> for Difference<'a, T> {
+impl<'a, T: Ord> Iterator for Difference<'a, T> {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
@@ -607,7 +614,9 @@ impl<'a, T: Ord> Iterator<&'a T> for Difference<'a, T> {
 }
 
 #[stable]
-impl<'a, T: Ord> Iterator<&'a T> for SymmetricDifference<'a, T> {
+impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
@@ -620,7 +629,9 @@ impl<'a, T: Ord> Iterator<&'a T> for SymmetricDifference<'a, T> {
 }
 
 #[stable]
-impl<'a, T: Ord> Iterator<&'a T> for Intersection<'a, T> {
+impl<'a, T: Ord> Iterator for Intersection<'a, T> {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             let o_cmp = match (self.a.peek(), self.b.peek()) {
@@ -639,7 +650,9 @@ impl<'a, T: Ord> Iterator<&'a T> for Intersection<'a, T> {
 }
 
 #[stable]
-impl<'a, T: Ord> Iterator<&'a T> for Union<'a, T> {
+impl<'a, T: Ord> Iterator for Union<'a, T> {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         loop {
             match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 68acbfcb3c3c8..b3d61f445639b 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -508,7 +508,9 @@ impl<T> Drop for DList<T> {
 }
 
 #[stable]
-impl<'a, A> Iterator<&'a A> for Iter<'a, A> {
+impl<'a, A> Iterator for Iter<'a, A> {
+    type Item = &'a A;
+
     #[inline]
     fn next(&mut self) -> Option<&'a A> {
         if self.nelem == 0 {
@@ -528,7 +530,7 @@ impl<'a, A> Iterator<&'a A> for Iter<'a, A> {
 }
 
 #[stable]
-impl<'a, A> DoubleEndedIterator<&'a A> for Iter<'a, A> {
+impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a A> {
         if self.nelem == 0 {
@@ -543,10 +545,11 @@ impl<'a, A> DoubleEndedIterator<&'a A> for Iter<'a, A> {
 }
 
 #[stable]
-impl<'a, A> ExactSizeIterator<&'a A> for Iter<'a, A> {}
+impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
 
 #[stable]
-impl<'a, A> Iterator<&'a mut A> for IterMut<'a, A> {
+impl<'a, A> Iterator for IterMut<'a, A> {
+    type Item = &'a mut A;
     #[inline]
     fn next(&mut self) -> Option<&'a mut A> {
         if self.nelem == 0 {
@@ -569,7 +572,7 @@ impl<'a, A> Iterator<&'a mut A> for IterMut<'a, A> {
 }
 
 #[stable]
-impl<'a, A> DoubleEndedIterator<&'a mut A> for IterMut<'a, A> {
+impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut A> {
         if self.nelem == 0 {
@@ -584,7 +587,7 @@ impl<'a, A> DoubleEndedIterator<&'a mut A> for IterMut<'a, A> {
 }
 
 #[stable]
-impl<'a, A> ExactSizeIterator<&'a mut A> for IterMut<'a, A> {}
+impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
 
 /// Allows mutating a `DList` while iterating.
 #[deprecated = "Trait is deprecated, use inherent methods on the iterator instead"]
@@ -676,7 +679,9 @@ impl<'a, A> IterMut<'a, A> {
 }
 
 #[stable]
-impl<A> Iterator<A> for IntoIter<A> {
+impl<A> Iterator for IntoIter<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> { self.list.pop_front() }
 
@@ -687,14 +692,14 @@ impl<A> Iterator<A> for IntoIter<A> {
 }
 
 #[stable]
-impl<A> DoubleEndedIterator<A> for IntoIter<A> {
+impl<A> DoubleEndedIterator for IntoIter<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
 }
 
 #[stable]
 impl<A> FromIterator<A> for DList<A> {
-    fn from_iter<T: Iterator<A>>(iterator: T) -> DList<A> {
+    fn from_iter<T: Iterator<Item=A>>(iterator: T) -> DList<A> {
         let mut ret = DList::new();
         ret.extend(iterator);
         ret
@@ -703,7 +708,7 @@ impl<A> FromIterator<A> for DList<A> {
 
 #[stable]
 impl<A> Extend<A> for DList<A> {
-    fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
+    fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {
         for elt in iterator { self.push_back(elt); }
     }
 }
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index ea3d8659f54a4..1d6caf2cceefd 100644
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -231,7 +231,9 @@ impl<E:CLike> Iter<E> {
     }
 }
 
-impl<E:CLike> Iterator<E> for Iter<E> {
+impl<E:CLike> Iterator for Iter<E> {
+    type Item = E;
+
     fn next(&mut self) -> Option<E> {
         if self.bits == 0 {
             return None;
@@ -254,7 +256,7 @@ impl<E:CLike> Iterator<E> for Iter<E> {
 }
 
 impl<E:CLike> FromIterator<E> for EnumSet<E> {
-    fn from_iter<I:Iterator<E>>(iterator: I) -> EnumSet<E> {
+    fn from_iter<I:Iterator<Item=E>>(iterator: I) -> EnumSet<E> {
         let mut ret = EnumSet::new();
         ret.extend(iterator);
         ret
@@ -262,7 +264,7 @@ impl<E:CLike> FromIterator<E> for EnumSet<E> {
 }
 
 impl<E:CLike> Extend<E> for EnumSet<E> {
-    fn extend<I: Iterator<E>>(&mut self, mut iterator: I) {
+    fn extend<I: Iterator<Item=E>>(&mut self, mut iterator: I) {
         for element in iterator {
             self.insert(element);
         }
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index fac9ab8107a72..fb9530882db35 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -110,7 +110,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, DoubleEndedIteratorExt};
+    pub use core::iter::{IteratorCloneExt, CloneIteratorExt};
     pub use core::iter::{IteratorOrdExt, MutableDoubleEndedIterator, ExactSizeIterator};
     pub use core::kinds::{Copy, Send, Sized, Sync};
     pub use core::mem::drop;
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index e4c9e51a8455b..eb58edbe453bd 100644
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -1151,7 +1151,9 @@ impl<'a, T> Clone for Iter<'a, T> {
 }
 
 #[stable]
-impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
     #[inline]
     fn next(&mut self) -> Option<&'a T> {
         if self.tail == self.head {
@@ -1170,7 +1172,7 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
 }
 
 #[stable]
-impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a T> {
         if self.tail == self.head {
@@ -1182,10 +1184,10 @@ impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
 }
 
 #[stable]
-impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 #[stable]
-impl<'a, T> RandomAccessIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
         let (len, _) = self.size_hint();
@@ -1217,7 +1219,9 @@ pub struct IterMut<'a, T:'a> {
 }
 
 #[stable]
-impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
+impl<'a, T> Iterator for IterMut<'a, T> {
+    type Item = &'a mut T;
+
     #[inline]
     fn next(&mut self) -> Option<&'a mut T> {
         if self.tail == self.head {
@@ -1239,7 +1243,7 @@ impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
 }
 
 #[stable]
-impl<'a, T> DoubleEndedIterator<&'a mut T> for IterMut<'a, T> {
+impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut T> {
         if self.tail == self.head {
@@ -1254,7 +1258,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut T> for IterMut<'a, T> {
 }
 
 #[stable]
-impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
+impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// A by-value RingBuf iterator
 #[stable]
@@ -1263,7 +1267,9 @@ pub struct IntoIter<T> {
 }
 
 #[stable]
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> {
         self.inner.pop_front()
@@ -1277,7 +1283,7 @@ impl<T> Iterator<T> for IntoIter<T> {
 }
 
 #[stable]
-impl<T> DoubleEndedIterator<T> for IntoIter<T> {
+impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
         self.inner.pop_back()
@@ -1285,7 +1291,7 @@ impl<T> DoubleEndedIterator<T> for IntoIter<T> {
 }
 
 #[stable]
-impl<T> ExactSizeIterator<T> for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// A draining RingBuf iterator
 #[unstable = "matches collection reform specification, waiting for dust to settle"]
@@ -1304,7 +1310,9 @@ impl<'a, T: 'a> Drop for Drain<'a, T> {
 }
 
 #[stable]
-impl<'a, T: 'a> Iterator<T> for Drain<'a, T> {
+impl<'a, T: 'a> Iterator for Drain<'a, T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> {
         self.inner.pop_front()
@@ -1318,7 +1326,7 @@ impl<'a, T: 'a> Iterator<T> for Drain<'a, T> {
 }
 
 #[stable]
-impl<'a, T: 'a> DoubleEndedIterator<T> for Drain<'a, T> {
+impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
         self.inner.pop_back()
@@ -1326,7 +1334,7 @@ impl<'a, T: 'a> DoubleEndedIterator<T> for Drain<'a, T> {
 }
 
 #[stable]
-impl<'a, T: 'a> ExactSizeIterator<T> for Drain<'a, T> {}
+impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
 
 #[stable]
 impl<A: PartialEq> PartialEq for RingBuf<A> {
@@ -1382,7 +1390,7 @@ impl<A> IndexMut<uint, A> for RingBuf<A> {
 
 #[stable]
 impl<A> FromIterator<A> for RingBuf<A> {
-    fn from_iter<T: Iterator<A>>(iterator: T) -> RingBuf<A> {
+    fn from_iter<T: Iterator<Item=A>>(iterator: T) -> RingBuf<A> {
         let (lower, _) = iterator.size_hint();
         let mut deq = RingBuf::with_capacity(lower);
         deq.extend(iterator);
@@ -1392,7 +1400,7 @@ impl<A> FromIterator<A> for RingBuf<A> {
 
 #[stable]
 impl<A> Extend<A> for RingBuf<A> {
-    fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
+    fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {
         for elt in iterator {
             self.push_back(elt);
         }
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 1c1b48f8cef67..5db4e8580d0a4 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -1140,7 +1140,9 @@ struct SizeDirection {
     dir: Direction,
 }
 
-impl Iterator<(uint, uint)> for ElementSwaps {
+impl Iterator for ElementSwaps {
+    type Item = (uint, uint);
+
     #[inline]
     fn next(&mut self) -> Option<(uint, uint)> {
         fn new_pos(i: uint, s: Direction) -> uint {
@@ -1207,7 +1209,9 @@ pub struct Permutations<T> {
 }
 
 #[unstable = "trait is unstable"]
-impl<T: Clone> Iterator<Vec<T>> for Permutations<T> {
+impl<T: Clone> Iterator for Permutations<T> {
+    type Item = Vec<T>;
+
     #[inline]
     fn next(&mut self) -> Option<Vec<T>> {
         match self.swaps.next() {
@@ -1445,7 +1449,7 @@ pub mod raw {
 mod tests {
     use std::boxed::Box;
     use prelude::{Some, None, range, Vec, ToString, Clone, Greater, Less, Equal};
-    use prelude::{SliceExt, Iterator, IteratorExt, DoubleEndedIteratorExt};
+    use prelude::{SliceExt, Iterator, IteratorExt};
     use prelude::AsSlice;
     use prelude::{RandomAccessIterator, Ord, SliceConcatExt};
     use core::cell::Cell;
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 129ba77d9f7a6..6c51480931b3b 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -181,7 +181,9 @@ pub struct Decompositions<'a> {
     sorted: bool
 }
 
-impl<'a> Iterator<char> for Decompositions<'a> {
+impl<'a> Iterator for Decompositions<'a> {
+    type Item = char;
+
     #[inline]
     fn next(&mut self) -> Option<char> {
         match self.buffer.first() {
@@ -268,7 +270,9 @@ pub struct Recompositions<'a> {
     last_ccc: Option<u8>
 }
 
-impl<'a> Iterator<char> for Recompositions<'a> {
+impl<'a> Iterator for Recompositions<'a> {
+    type Item = char;
+
     #[inline]
     fn next(&mut self) -> Option<char> {
         loop {
@@ -357,7 +361,9 @@ pub struct Utf16Units<'a> {
     encoder: Utf16Encoder<Chars<'a>>
 }
 
-impl<'a> Iterator<u16> for Utf16Units<'a> {
+impl<'a> Iterator for Utf16Units<'a> {
+    type Item = u16;
+
     #[inline]
     fn next(&mut self) -> Option<u16> { self.encoder.next() }
 
@@ -3272,7 +3278,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use prelude::{SliceExt, IteratorExt, DoubleEndedIteratorExt, SliceConcatExt};
+    use prelude::{SliceExt, IteratorExt, SliceConcatExt};
     use test::Bencher;
     use test::black_box;
 
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 769679ec4d448..99273d9575ba1 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -781,7 +781,7 @@ impl fmt::Show for FromUtf16Error {
 
 #[experimental = "waiting on FromIterator stabilization"]
 impl FromIterator<char> for String {
-    fn from_iter<I:Iterator<char>>(iterator: I) -> String {
+    fn from_iter<I:Iterator<Item=char>>(iterator: I) -> String {
         let mut buf = String::new();
         buf.extend(iterator);
         buf
@@ -790,7 +790,7 @@ impl FromIterator<char> for String {
 
 #[experimental = "waiting on FromIterator stabilization"]
 impl<'a> FromIterator<&'a str> for String {
-    fn from_iter<I:Iterator<&'a str>>(iterator: I) -> String {
+    fn from_iter<I:Iterator<Item=&'a str>>(iterator: I) -> String {
         let mut buf = String::new();
         buf.extend(iterator);
         buf
@@ -799,7 +799,7 @@ impl<'a> FromIterator<&'a str> for String {
 
 #[experimental = "waiting on Extend stabilization"]
 impl Extend<char> for String {
-    fn extend<I:Iterator<char>>(&mut self, mut iterator: I) {
+    fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) {
         let (lower_bound, _) = iterator.size_hint();
         self.reserve(lower_bound);
         for ch in iterator {
@@ -810,7 +810,7 @@ impl Extend<char> for String {
 
 #[experimental = "waiting on Extend stabilization"]
 impl<'a> Extend<&'a str> for String {
-    fn extend<I: Iterator<&'a str>>(&mut self, mut iterator: I) {
+    fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) {
         // A guess that at least one byte per iterator element will be needed.
         let (lower_bound, _) = iterator.size_hint();
         self.reserve(lower_bound);
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 7e36792742171..cba2824cf9bcb 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1164,7 +1164,7 @@ impl<T: PartialEq> Vec<T> {
 
 /// Deprecated: use `unzip` directly on the iterator instead.
 #[deprecated = "use unzip directly on the iterator instead"]
-pub fn unzip<T, U, V: Iterator<(T, U)>>(iter: V) -> (Vec<T>, Vec<U>) {
+pub fn unzip<T, U, V: Iterator<Item=(T, U)>>(iter: V) -> (Vec<T>, Vec<U>) {
     iter.unzip()
 }
 
@@ -1317,7 +1317,7 @@ impl<T> ops::DerefMut for Vec<T> {
 #[experimental = "waiting on FromIterator stability"]
 impl<T> FromIterator<T> for Vec<T> {
     #[inline]
-    fn from_iter<I:Iterator<T>>(mut iterator: I) -> Vec<T> {
+    fn from_iter<I:Iterator<Item=T>>(mut iterator: I) -> Vec<T> {
         let (lower, _) = iterator.size_hint();
         let mut vector = Vec::with_capacity(lower);
         for element in iterator {
@@ -1330,7 +1330,7 @@ impl<T> FromIterator<T> for Vec<T> {
 #[experimental = "waiting on Extend stability"]
 impl<T> Extend<T> for Vec<T> {
     #[inline]
-    fn extend<I: Iterator<T>>(&mut self, mut iterator: I) {
+    fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) {
         let (lower, _) = iterator.size_hint();
         self.reserve(lower);
         for element in iterator {
@@ -1506,7 +1506,7 @@ impl<'a> fmt::Writer for Vec<u8> {
 pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>;
 
 impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
-    fn from_iter<I: Iterator<T>>(it: I) -> CowVec<'a, T> {
+    fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
         Cow::Owned(FromIterator::from_iter(it))
     }
 }
@@ -1557,7 +1557,9 @@ impl<T> IntoIter<T> {
     pub fn unwrap(self) -> Vec<T> { self.into_inner() }
 }
 
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     #[inline]
     fn next<'a>(&'a mut self) -> Option<T> {
         unsafe {
@@ -1591,7 +1593,7 @@ impl<T> Iterator<T> for IntoIter<T> {
     }
 }
 
-impl<T> DoubleEndedIterator<T> for IntoIter<T> {
+impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back<'a>(&'a mut self) -> Option<T> {
         unsafe {
@@ -1614,7 +1616,7 @@ impl<T> DoubleEndedIterator<T> for IntoIter<T> {
     }
 }
 
-impl<T> ExactSizeIterator<T> for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 #[unsafe_destructor]
 impl<T> Drop for IntoIter<T> {
@@ -1638,7 +1640,9 @@ pub struct Drain<'a, T> {
     marker: ContravariantLifetime<'a>,
 }
 
-impl<'a, T> Iterator<T> for Drain<'a, T> {
+impl<'a, T> Iterator for Drain<'a, T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> {
         unsafe {
@@ -1672,7 +1676,7 @@ impl<'a, T> Iterator<T> for Drain<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator<T> for Drain<'a, T> {
+impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
         unsafe {
@@ -1695,7 +1699,7 @@ impl<'a, T> DoubleEndedIterator<T> for Drain<'a, T> {
     }
 }
 
-impl<'a, T> ExactSizeIterator<T> for Drain<'a, T> {}
+impl<'a, T> ExactSizeIterator for Drain<'a, T> {}
 
 #[unsafe_destructor]
 impl<'a, T> Drop for Drain<'a, T> {
diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
index 172fd56ed3962..bf0c8f10e5ff0 100644
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@@ -546,7 +546,7 @@ impl<V: fmt::Show> fmt::Show for VecMap<V> {
 
 #[stable]
 impl<V> FromIterator<(uint, V)> for VecMap<V> {
-    fn from_iter<Iter: Iterator<(uint, V)>>(iter: Iter) -> VecMap<V> {
+    fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
         let mut map = VecMap::new();
         map.extend(iter);
         map
@@ -555,7 +555,7 @@ impl<V> FromIterator<(uint, V)> for VecMap<V> {
 
 #[stable]
 impl<V> Extend<(uint, V)> for VecMap<V> {
-    fn extend<Iter: Iterator<(uint, V)>>(&mut self, mut iter: Iter) {
+    fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);
         }
@@ -581,7 +581,9 @@ impl<V> IndexMut<uint, V> for VecMap<V> {
 macro_rules! iterator {
     (impl $name:ident -> $elem:ty, $($getter:ident),+) => {
         #[stable]
-        impl<'a, V> Iterator<$elem> for $name<'a, V> {
+        impl<'a, V> Iterator for $name<'a, V> {
+            type Item = $elem;
+
             #[inline]
             fn next(&mut self) -> Option<$elem> {
                 while self.front < self.back {
@@ -614,7 +616,7 @@ macro_rules! iterator {
 macro_rules! double_ended_iterator {
     (impl $name:ident -> $elem:ty, $($getter:ident),+) => {
         #[stable]
-        impl<'a, V> DoubleEndedIterator<$elem> for $name<'a, V> {
+        impl<'a, V> DoubleEndedIterator for $name<'a, V> {
             #[inline]
             fn next_back(&mut self) -> Option<$elem> {
                 while self.front < self.back {
@@ -713,32 +715,38 @@ pub struct IntoIter<V> {
 }
 
 #[stable]
-impl<'a, V> Iterator<uint> for Keys<'a, V> {
+impl<'a, V> Iterator for Keys<'a, V> {
+    type Item = uint;
+
     fn next(&mut self) -> Option<uint> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 #[stable]
-impl<'a, V> DoubleEndedIterator<uint> for Keys<'a, V> {
+impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
     fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
 }
 
 #[stable]
-impl<'a, V> Iterator<&'a V> for Values<'a, V> {
+impl<'a, V> Iterator for Values<'a, V> {
+    type Item = &'a V;
+
     fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 #[stable]
-impl<'a, V> DoubleEndedIterator<&'a V> for Values<'a, V> {
+impl<'a, V> DoubleEndedIterator for Values<'a, V> {
     fn next_back(&mut self) -> Option<(&'a V)> { self.iter.next_back() }
 }
 
 #[stable]
-impl<V> Iterator<(uint, V)> for IntoIter<V> {
+impl<V> Iterator for IntoIter<V> {
+    type Item = (uint, V);
+
     fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 #[stable]
-impl<V> DoubleEndedIterator<(uint, V)> for IntoIter<V> {
+impl<V> DoubleEndedIterator for IntoIter<V> {
     fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
 }
 
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index f0151dda8d71e..aa6028a19b323 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -446,7 +446,9 @@ enum EscapeUnicodeState {
     Done,
 }
 
-impl Iterator<char> for EscapeUnicode {
+impl Iterator for EscapeUnicode {
+    type Item = char;
+
     fn next(&mut self) -> Option<char> {
         match self.state {
             EscapeUnicodeState::Backslash => {
@@ -501,7 +503,9 @@ enum EscapeDefaultState {
     Unicode(EscapeUnicode),
 }
 
-impl Iterator<char> for EscapeDefault {
+impl Iterator for EscapeDefault {
+    type Item = char;
+
     fn next(&mut self) -> Option<char> {
         match self.state {
             EscapeDefaultState::Backslash(c) => {
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index a39168ec1ec82..27023fab858d9 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -17,7 +17,7 @@ pub use self::SignFormat::*;
 use char;
 use char::Char;
 use fmt;
-use iter::{range, DoubleEndedIteratorExt};
+use iter::{IteratorExt, range};
 use num::{cast, Float, ToPrimitive};
 use num::FpCategory as Fp;
 use ops::FnOnce;
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 4f0cecbb24353..e680230265aa6 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -15,7 +15,7 @@
 #![allow(unsigned_negation)]
 
 use fmt;
-use iter::DoubleEndedIteratorExt;
+use iter::IteratorExt;
 use num::{Int, cast};
 use slice::SliceExt;
 use str;
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index d7a675b3104ec..963377ff6b330 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -82,9 +82,11 @@ use uint;
 /// else.
 #[lang="iterator"]
 #[unstable = "just split up for object safety"]
-pub trait Iterator<A> {
+pub trait Iterator {
+    type Item;
+
     /// Advance the iterator and return the next value. Return `None` when the end is reached.
-    fn next(&mut self) -> Option<A>;
+    fn next(&mut self) -> Option<Self::Item>;
 
     /// Returns a lower and upper bound on the remaining length of the iterator.
     ///
@@ -98,19 +100,19 @@ pub trait Iterator<A> {
 #[unstable = "may be replaced by a more general conversion trait"]
 pub trait FromIterator<A> {
     /// Build a container with elements from an external iterator.
-    fn from_iter<T: Iterator<A>>(iterator: T) -> Self;
+    fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
 }
 
 /// A type growable from an `Iterator` implementation
 #[unstable = "just renamed as part of collections reform"]
 pub trait Extend<A> {
     /// Extend a container with the elements yielded by an arbitrary iterator
-    fn extend<T: Iterator<A>>(&mut self, iterator: T);
+    fn extend<T: Iterator<Item=A>>(&mut self, iterator: T);
 }
 
 #[unstable = "new convention for extension traits"]
 /// An extension trait providing numerous methods applicable to all iterators.
-pub trait IteratorExt<A>: Iterator<A> + Sized {
+pub trait IteratorExt: Iterator + Sized {
     /// Chain this iterator with another, returning a new iterator that will
     /// finish iterating over the current iterator, and then iterate
     /// over the other specified iterator.
@@ -127,7 +129,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[stable]
-    fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U> {
+    fn chain<U>(self, other: U) -> Chain<Self, U> where
+        U: Iterator<Item=<Self as Iterator>::Item>,
+    {
         Chain{a: self, b: other, flag: false}
     }
 
@@ -148,7 +152,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[stable]
-    fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U> {
+    fn zip<B, U>(self, other: U) -> Zip<Self, U> where
+        U: Iterator<Item=B>,
+    {
         Zip{a: self, b: other}
     }
 
@@ -166,7 +172,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn map<B, F: FnMut(A) -> B>(self, f: F) -> Map<A, B, Self, F> {
+    fn map<B, F>(self, f: F) -> Map< <Self as Iterator>::Item, B, Self, F> where
+        F: FnMut(<Self as Iterator>::Item) -> B,
+    {
         Map{iter: self, f: f}
     }
 
@@ -184,7 +192,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn filter<P>(self, predicate: P) -> Filter<A, Self, P> where P: FnMut(&A) -> bool {
+    fn filter<P>(self, predicate: P) -> Filter< <Self as Iterator>::Item, Self, P> where
+        P: FnMut(&<Self as Iterator>::Item) -> bool,
+    {
         Filter{iter: self, predicate: predicate}
     }
 
@@ -202,7 +212,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn filter_map<B, F>(self, f: F) -> FilterMap<A, B, Self, F> where F: FnMut(A) -> Option<B> {
+    fn filter_map<B, F>(self, f: F) -> FilterMap< <Self as Iterator>::Item, B, Self, F> where
+        F: FnMut(<Self as Iterator>::Item) -> Option<B>,
+    {
         FilterMap { iter: self, f: f }
     }
 
@@ -244,7 +256,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[stable]
-    fn peekable(self) -> Peekable<A, Self> {
+    fn peekable(self) -> Peekable< <Self as Iterator>::Item, Self> {
         Peekable{iter: self, peeked: None}
     }
 
@@ -264,7 +276,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn skip_while<P>(self, predicate: P) -> SkipWhile<A, Self, P> where P: FnMut(&A) -> bool {
+    fn skip_while<P>(self, predicate: P) -> SkipWhile< <Self as Iterator>::Item, Self, P> where
+        P: FnMut(&<Self as Iterator>::Item) -> bool,
+    {
         SkipWhile{iter: self, flag: false, predicate: predicate}
     }
 
@@ -283,7 +297,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures, may want to require peek"]
-    fn take_while<P>(self, predicate: P) -> TakeWhile<A, Self, P> where P: FnMut(&A) -> bool {
+    fn take_while<P>(self, predicate: P) -> TakeWhile< <Self as Iterator>::Item, Self, P> where
+        P: FnMut(&<Self as Iterator>::Item) -> bool,
+    {
         TakeWhile{iter: self, flag: false, predicate: predicate}
     }
 
@@ -346,8 +362,12 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<A, B, Self, St, F> where
-        F: FnMut(&mut St, A) -> Option<B>,
+    fn scan<St, B, F>(
+        self,
+        initial_state: St,
+        f: F,
+    ) -> Scan< <Self as Iterator>::Item, B, Self, St, F> where
+        F: FnMut(&mut St, <Self as Iterator>::Item) -> Option<B>,
     {
         Scan{iter: self, f: f, state: initial_state}
     }
@@ -372,9 +392,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn flat_map<B, U, F>(self, f: F) -> FlatMap<A, B, Self, U, F> where
-        U: Iterator<B>,
-        F: FnMut(A) -> U,
+    fn flat_map<B, U, F>(self, f: F) -> FlatMap< <Self as Iterator>::Item, B, Self, U, F> where
+        U: Iterator<Item=B>,
+        F: FnMut(<Self as Iterator>::Item) -> U,
     {
         FlatMap{iter: self, f: f, frontiter: None, backiter: None }
     }
@@ -386,7 +406,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// # Example
     ///
     /// ```rust
-    /// fn process<U: Iterator<int>>(it: U) -> int {
+    /// fn process<U: Iterator<Item=int>>(it: U) -> int {
     ///     let mut it = it.fuse();
     ///     let mut sum = 0;
     ///     for x in it {
@@ -432,7 +452,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn inspect<F>(self, f: F) -> Inspect<A, Self, F> where F: FnMut(&A) {
+    fn inspect<F>(self, f: F) -> Inspect< <Self as Iterator>::Item, Self, F> where
+        F: FnMut(&<Self as Iterator>::Item),
+    {
         Inspect{iter: self, f: f}
     }
 
@@ -468,7 +490,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for general conversion traits, just changed to take self by value"]
-    fn collect<B: FromIterator<A>>(self) -> B {
+    fn collect<B: FromIterator< <Self as Iterator>::Item>>(self) -> B {
         FromIterator::from_iter(self)
     }
 
@@ -485,7 +507,8 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[unstable = "recently added as part of collections reform"]
     fn partition<B, F>(mut self, mut f: F) -> (B, B) where
-        B: Default + Extend<A>, F: FnMut(&A) -> bool
+        B: Default + Extend< <Self as Iterator>::Item>,
+        F: FnMut(&<Self as Iterator>::Item) -> bool
     {
         let mut left: B = Default::default();
         let mut right: B = Default::default();
@@ -514,7 +537,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[stable]
-    fn nth(&mut self, mut n: uint) -> Option<A> {
+    fn nth(&mut self, mut n: uint) -> Option< <Self as Iterator>::Item> {
         for x in *self {
             if n == 0 { return Some(x) }
             n -= 1;
@@ -533,7 +556,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "just changed to take self by value"]
-    fn last(mut self) -> Option<A> {
+    fn last(mut self) -> Option< <Self as Iterator>::Item> {
         let mut last = None;
         for x in self { last = Some(x); }
         last
@@ -550,7 +573,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures, just changed to take self by value"]
-    fn fold<B, F>(mut self, init: B, mut f: F) -> B where F: FnMut(B, A) -> B {
+    fn fold<B, F>(mut self, init: B, mut f: F) -> B where
+        F: FnMut(B, <Self as Iterator>::Item) -> B,
+    {
         let mut accum = init;
         for x in self {
             accum = f(accum, x);
@@ -584,7 +609,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures, just changed to take self by value"]
-    fn all<F>(mut self, mut f: F) -> bool where F: FnMut(A) -> bool {
+    fn all<F>(mut self, mut f: F) -> bool where F: FnMut(<Self as Iterator>::Item) -> bool {
         for x in self { if !f(x) { return false; } }
         true
     }
@@ -602,7 +627,7 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(A) -> bool {
+    fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(<Self as Iterator>::Item) -> bool {
         for x in *self { if f(x) { return true; } }
         false
     }
@@ -612,7 +637,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// Does not consume the iterator past the first found element.
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn find<P>(&mut self, mut predicate: P) -> Option<A> where P: FnMut(&A) -> bool {
+    fn find<P>(&mut self, mut predicate: P) -> Option< <Self as Iterator>::Item> where
+        P: FnMut(&<Self as Iterator>::Item) -> bool,
+    {
         for x in *self {
             if predicate(&x) { return Some(x) }
         }
@@ -622,7 +649,9 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// Return the index of the first element satisfying the specified predicate
     #[inline]
     #[unstable = "waiting for unboxed closures"]
-    fn position<P>(&mut self, mut predicate: P) -> Option<uint> where P: FnMut(A) -> bool {
+    fn position<P>(&mut self, mut predicate: P) -> Option<uint> where
+        P: FnMut(<Self as Iterator>::Item) -> bool,
+    {
         let mut i = 0;
         for x in *self {
             if predicate(x) {
@@ -646,8 +675,10 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures, just changed to take self by value"]
-    fn max_by<B: Ord, F>(self, mut f: F) -> Option<A> where F: FnMut(&A) -> B {
-        self.fold(None, |max: Option<(A, B)>, x| {
+    fn max_by<B: Ord, F>(self, mut f: F) -> Option< <Self as Iterator>::Item> where
+        F: FnMut(&<Self as Iterator>::Item) -> B,
+    {
+        self.fold(None, |max: Option<(<Self as Iterator>::Item, B)>, x| {
             let x_val = f(&x);
             match max {
                 None             => Some((x, x_val)),
@@ -673,8 +704,10 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
     /// ```
     #[inline]
     #[unstable = "waiting for unboxed closures, just changed to take self by value"]
-    fn min_by<B: Ord, F>(self, mut f: F) -> Option<A> where F: FnMut(&A) -> B {
-        self.fold(None, |min: Option<(A, B)>, x| {
+    fn min_by<B: Ord, F>(self, mut f: F) -> Option< <Self as Iterator>::Item> where
+        F: FnMut(&<Self as Iterator>::Item) -> B,
+    {
+        self.fold(None, |min: Option<(<Self as Iterator>::Item, B)>, x| {
             let x_val = f(&x);
             match min {
                 None             => Some((x, x_val)),
@@ -686,23 +719,38 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
             }
         }).map(|(x, _)| x)
     }
-}
 
-#[unstable = "trait is unstable"]
-impl<A, I> IteratorExt<A> for I where I: Iterator<A> {}
+    /// Change the direction of the iterator
+    ///
+    /// The flipped iterator swaps the ends on an iterator that can already
+    /// be iterated from the front and from the back.
+    ///
+    ///
+    /// If the iterator also implements RandomAccessIterator, the flipped
+    /// iterator is also random access, with the indices starting at the back
+    /// of the original iterator.
+    ///
+    /// Note: Random access with flipped indices still only applies to the first
+    /// `uint::MAX` elements of the original iterator.
+    #[inline]
+    #[stable]
+    fn rev(self) -> Rev<Self> {
+        Rev{iter: self}
+    }
 
-/// Extention trait for iterators of pairs.
-#[unstable = "newly added trait, likely to be merged with IteratorExt"]
-pub trait IteratorPairExt<A, B>: Iterator<(A, B)> + Sized {
     /// 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: Default + Extend<A>, FromB: Default + Extend<B>
+    fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where
+        FromA: Default + Extend<A>,
+        FromB: Default + Extend<B>,
+        Self: Iterator<Item=(A, B)>,
     {
         struct SizeHint<A>(uint, Option<uint>);
-        impl<A> Iterator<A> for SizeHint<A> {
+        impl<A> Iterator for SizeHint<A> {
+            type Item = A;
+
             fn next(&mut self) -> Option<A> { None }
             fn size_hint(&self) -> (uint, Option<uint>) {
                 (self.0, self.1)
@@ -725,43 +773,19 @@ pub trait IteratorPairExt<A, B>: Iterator<(A, B)> + Sized {
     }
 }
 
-impl<A, B, I> IteratorPairExt<A, B> for I where I: Iterator<(A, B)> {}
+#[unstable = "trait is unstable"]
+impl<I> IteratorExt for I where I: Iterator {}
 
 /// A range iterator able to yield elements from both ends
 ///
 /// A `DoubleEndedIterator` can be thought of as a deque in that `next()` and `next_back()` exhaust
 /// elements from the *same* range, and do not work independently of each other.
 #[unstable = "recently split into two traits"]
-pub trait DoubleEndedIterator<A>: Iterator<A> {
+pub trait DoubleEndedIterator: Iterator {
     /// Yield an element from the end of the range, returning `None` if the range is empty.
-    fn next_back(&mut self) -> Option<A>;
-}
-
-/// Extension methods for double-ended iterators.
-#[unstable = "new extension trait convention"]
-pub trait DoubleEndedIteratorExt<A>: DoubleEndedIterator<A> + Sized {
-    /// Change the direction of the iterator
-    ///
-    /// The flipped iterator swaps the ends on an iterator that can already
-    /// be iterated from the front and from the back.
-    ///
-    ///
-    /// If the iterator also implements RandomAccessIterator, the flipped
-    /// iterator is also random access, with the indices starting at the back
-    /// of the original iterator.
-    ///
-    /// Note: Random access with flipped indices still only applies to the first
-    /// `uint::MAX` elements of the original iterator.
-    #[inline]
-    #[stable]
-    fn rev(self) -> Rev<Self> {
-        Rev{iter: self}
-    }
+    fn next_back(&mut self) -> Option< <Self as Iterator>::Item>;
 }
 
-#[unstable = "trait is unstable"]
-impl<A, I> DoubleEndedIteratorExt<A> for I where I: DoubleEndedIterator<A> {}
-
 /// A double-ended iterator yielding mutable references
 #[experimental = "not widely used"]
 pub trait MutableDoubleEndedIterator {
@@ -771,7 +795,9 @@ pub trait MutableDoubleEndedIterator {
 }
 
 #[experimental = "trait is experimental"]
-impl<'a, A:'a, T: DoubleEndedIterator<&'a mut A>> MutableDoubleEndedIterator for T {
+impl<'a, T:'a, I> MutableDoubleEndedIterator for I where
+    I: DoubleEndedIterator + Iterator<Item=&'a mut T>,
+{
     // FIXME: #5898: should be called `reverse`
     /// Use an iterator to reverse a container in-place
     fn reverse_(&mut self) {
@@ -792,13 +818,13 @@ impl<'a, A:'a, T: DoubleEndedIterator<&'a mut A>> MutableDoubleEndedIterator for
 /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)`
 /// after `it.next()` is called.
 #[experimental = "not widely used, may be better decomposed into Index and ExactSizeIterator"]
-pub trait RandomAccessIterator<A>: Iterator<A> {
+pub trait RandomAccessIterator: Iterator {
     /// Return the number of indexable elements. At most `std::uint::MAX`
     /// elements are indexable, even if the iterator represents a longer range.
     fn indexable(&self) -> uint;
 
     /// Return an element at an index, or `None` if the index is out of bounds
-    fn idx(&mut self, index: uint) -> Option<A>;
+    fn idx(&mut self, index: uint) -> Option< <Self as Iterator>::Item>;
 }
 
 /// An iterator that knows its exact length
@@ -809,12 +835,14 @@ pub trait RandomAccessIterator<A>: Iterator<A> {
 /// `Iterator::size_hint` *must* return the exact size of the iterator.
 /// Note that the size must fit in `uint`.
 #[unstable = "could move DoubleEndedIterator bound onto rposition with method-level where clauses"]
-pub trait ExactSizeIterator<A> : DoubleEndedIterator<A> {
+pub trait ExactSizeIterator: DoubleEndedIterator {
     /// Return the index of the last element satisfying the specified predicate
     ///
     /// If no element matches, None is returned.
     #[inline]
-    fn rposition<P>(&mut self, mut predicate: P) -> Option<uint> where P: FnMut(A) -> bool {
+    fn rposition<P>(&mut self, mut predicate: P) -> Option<uint> where
+        P: FnMut(<Self as Iterator>::Item) -> bool,
+    {
         let len = self.len();
         for i in range(0, len).rev() {
             if predicate(self.next_back().expect("rposition: incorrect ExactSizeIterator")) {
@@ -840,22 +868,21 @@ pub trait ExactSizeIterator<A> : DoubleEndedIterator<A> {
 // All adaptors that preserve the size of the wrapped iterator are fine
 // Adaptors that may overflow in `size_hint` are not, i.e. `Chain`.
 #[unstable = "trait is unstable"]
-impl<A, T: ExactSizeIterator<A>> ExactSizeIterator<(uint, A)> for Enumerate<T> {}
+impl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {}
 #[unstable = "trait is unstable"]
-impl<A, I, F> ExactSizeIterator<A> for Inspect<A, I, F> where
-    I: ExactSizeIterator<A>,
+impl<A, I, F> ExactSizeIterator for Inspect<A, I, F> where
+    I: ExactSizeIterator + Iterator<Item=A>,
     F: FnMut(&A),
 {}
 #[unstable = "trait is unstable"]
-impl<A, T: ExactSizeIterator<A>> ExactSizeIterator<A> for Rev<T> {}
+impl<I> ExactSizeIterator for Rev<I> where I: ExactSizeIterator {}
 #[unstable = "trait is unstable"]
-impl<A, B, I, F> ExactSizeIterator<B> for Map<A, B, I, F> where
-    I: ExactSizeIterator<A>,
+impl<A, B, I, F> ExactSizeIterator for Map<A, B, I, F> where
+    I: ExactSizeIterator + Iterator<Item=A>,
     F: FnMut(A) -> B,
 {}
 #[unstable = "trait is unstable"]
-impl<A, B, T, U> ExactSizeIterator<(A, B)> for Zip<T, U>
-    where T: ExactSizeIterator<A>, U: ExactSizeIterator<B> {}
+impl<A, B> ExactSizeIterator for Zip<A, B> where A: ExactSizeIterator, B: ExactSizeIterator {}
 
 /// An double-ended iterator with the direction inverted
 #[deriving(Clone)]
@@ -866,26 +893,27 @@ pub struct Rev<T> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: DoubleEndedIterator<A>> Iterator<A> for Rev<T> {
+impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> { self.iter.next_back() }
+    fn next(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next_back() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Rev<T> {
+impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
     #[inline]
-    fn next_back(&mut self) -> Option<A> { self.iter.next() }
+    fn next_back(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next() }
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterator<A>
-    for Rev<T> {
+impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint { self.iter.indexable() }
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
         let amt = self.indexable();
         self.iter.idx(amt - index - 1)
     }
@@ -894,22 +922,24 @@ impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterato
 /// A mutable reference to an iterator
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct ByRef<'a, T:'a> {
-    iter: &'a mut T
+pub struct ByRef<'a, I:'a> {
+    iter: &'a mut I,
 }
 
 #[unstable = "trait is unstable"]
-impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> {
+impl<'a, I> Iterator for ByRef<'a, I> where I: 'a + Iterator {
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> { self.iter.next() }
+    fn next(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 #[unstable = "trait is unstable"]
-impl<'a, A, T: DoubleEndedIterator<A>+'a> DoubleEndedIterator<A> for ByRef<'a, T> {
+impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterator {
     #[inline]
-    fn next_back(&mut self) -> Option<A> { self.iter.next_back() }
+    fn next_back(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next_back() }
 }
 
 /// A trait for iterators over elements which can be added together
@@ -932,7 +962,7 @@ pub trait AdditiveIterator<A> {
 macro_rules! impl_additive {
     ($A:ty, $init:expr) => {
         #[experimental = "trait is experimental"]
-        impl<T: Iterator<$A>> AdditiveIterator<$A> for T {
+        impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T {
             #[inline]
             fn sum(self) -> $A {
                 self.fold($init, |acc, x| acc + x)
@@ -976,7 +1006,7 @@ pub trait MultiplicativeIterator<A> {
 macro_rules! impl_multiplicative {
     ($A:ty, $init:expr) => {
         #[experimental = "trait is experimental"]
-        impl<T: Iterator<$A>> MultiplicativeIterator<$A> for T {
+        impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T {
             #[inline]
             fn product(self) -> $A {
                 self.fold($init, |acc, x| acc * x)
@@ -1057,9 +1087,9 @@ pub trait IteratorOrdExt<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Ord, T: Iterator<A>> IteratorOrdExt<A> for T {
+impl<T, I> IteratorOrdExt<T> for I where I: Iterator<Item=T>, T: Ord {
     #[inline]
-    fn max(self) -> Option<A> {
+    fn max(self) -> Option<T> {
         self.fold(None, |max, x| {
             match max {
                 None    => Some(x),
@@ -1069,7 +1099,7 @@ impl<A: Ord, T: Iterator<A>> IteratorOrdExt<A> for T {
     }
 
     #[inline]
-    fn min(self) -> Option<A> {
+    fn min(self) -> Option<T> {
         self.fold(None, |min, x| {
             match min {
                 None    => Some(x),
@@ -1078,7 +1108,7 @@ impl<A: Ord, T: Iterator<A>> IteratorOrdExt<A> for T {
         })
     }
 
-    fn min_max(mut self) -> MinMaxResult<A> {
+    fn min_max(mut self) -> MinMaxResult<T> {
         let (mut min, mut max) = match self.next() {
             None => return NoElements,
             Some(x) => {
@@ -1175,7 +1205,11 @@ pub trait IteratorCloneExt<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Clone, D: Deref<Target=A>, I: Iterator<D>> IteratorCloneExt<A> for I {
+impl<T, D, I> IteratorCloneExt<T> for I where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: Iterator<Item=D>,
+{
     fn cloned(self) -> Cloned<I> {
         Cloned { it: self }
     }
@@ -1186,8 +1220,14 @@ pub struct Cloned<I> {
     it: I,
 }
 
-impl<A: Clone, D: Deref<Target=A>, I: Iterator<D>> Iterator<A> for Cloned<I> {
-    fn next(&mut self) -> Option<A> {
+impl<T, D, I> Iterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: Iterator<Item=D>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
         self.it.next().cloned()
     }
 
@@ -1196,15 +1236,22 @@ impl<A: Clone, D: Deref<Target=A>, I: Iterator<D>> Iterator<A> for Cloned<I> {
     }
 }
 
-impl<A: Clone, D: Deref<Target=A>, I: DoubleEndedIterator<D>>
-        DoubleEndedIterator<A> for Cloned<I> {
-    fn next_back(&mut self) -> Option<A> {
+impl<T, D, I> DoubleEndedIterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: DoubleEndedIterator + Iterator<Item=D>,
+{
+    fn next_back(&mut self) -> Option<T> {
         self.it.next_back().cloned()
     }
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Clone, D: Deref<Target=A>, I: ExactSizeIterator<D>> ExactSizeIterator<A> for Cloned<I> {}
+impl<T, D, I> ExactSizeIterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: ExactSizeIterator + Iterator<Item=D>,
+{}
 
 #[unstable = "recently renamed for extension trait conventions"]
 /// An extension trait for cloneable iterators.
@@ -1225,7 +1272,7 @@ pub trait CloneIteratorExt {
     fn cycle(self) -> Cycle<Self>;
 }
 
-impl<A, I> CloneIteratorExt for I where I: Iterator<A> + Clone {
+impl<I> CloneIteratorExt for I where I: Iterator + Clone {
     #[inline]
     fn cycle(self) -> Cycle<I> {
         Cycle{orig: self.clone(), iter: self}
@@ -1236,14 +1283,16 @@ impl<A, I> CloneIteratorExt for I where I: Iterator<A> + Clone {
 #[deriving(Clone, Copy)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Cycle<T> {
-    orig: T,
-    iter: T,
+pub struct Cycle<I> {
+    orig: I,
+    iter: I,
 }
 
-impl<A, T: Clone + Iterator<A>> Iterator<A> for Cycle<T> {
+impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option< <I as Iterator>::Item> {
         match self.iter.next() {
             None => { self.iter = self.orig.clone(); self.iter.next() }
             y => y
@@ -1262,7 +1311,9 @@ impl<A, T: Clone + Iterator<A>> Iterator<A> for Cycle<T> {
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T> {
+impl<I> RandomAccessIterator for Cycle<I> where
+    I: Clone + RandomAccessIterator,
+{
     #[inline]
     fn indexable(&self) -> uint {
         if self.orig.indexable() > 0 {
@@ -1273,7 +1324,7 @@ impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T>
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
         let liter = self.iter.indexable();
         let lorig = self.orig.indexable();
         if lorig == 0 {
@@ -1290,16 +1341,18 @@ impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T>
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Chain<T, U> {
-    a: T,
-    b: U,
+pub struct Chain<A, B> {
+    a: A,
+    b: B,
     flag: bool,
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> {
+impl<T, A, B> Iterator for Chain<A, B> where A: Iterator<Item=T>, B: Iterator<Item=T> {
+    type Item = T;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option<T> {
         if self.flag {
             self.b.next()
         } else {
@@ -1329,10 +1382,12 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: DoubleEndedIterator<A>, U: DoubleEndedIterator<A>> DoubleEndedIterator<A>
-for Chain<T, U> {
+impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
+    A: DoubleEndedIterator + Iterator<Item=T>,
+    B: DoubleEndedIterator + Iterator<Item=T>,
+{
     #[inline]
-    fn next_back(&mut self) -> Option<A> {
+    fn next_back(&mut self) -> Option<T> {
         match self.b.next_back() {
             Some(x) => Some(x),
             None => self.a.next_back()
@@ -1341,8 +1396,10 @@ for Chain<T, U> {
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: RandomAccessIterator<A>, U: RandomAccessIterator<A>> RandomAccessIterator<A>
-for Chain<T, U> {
+impl<T, A, B> RandomAccessIterator for Chain<A, B> where
+    A: RandomAccessIterator + Iterator<Item=T>,
+    B: RandomAccessIterator + Iterator<Item=T>,
+{
     #[inline]
     fn indexable(&self) -> uint {
         let (a, b) = (self.a.indexable(), self.b.indexable());
@@ -1350,7 +1407,7 @@ for Chain<T, U> {
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option<T> {
         let len = self.a.indexable();
         if index < len {
             self.a.idx(index)
@@ -1364,15 +1421,20 @@ for Chain<T, U> {
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Zip<T, U> {
-    a: T,
-    b: U
+pub struct Zip<A, B> {
+    a: A,
+    b: B
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for Zip<T, U> {
+impl<T, U, A, B> Iterator for Zip<A, B> where
+    A: Iterator<Item = T>,
+    B: Iterator<Item = U>,
+{
+    type Item = (T, U);
+
     #[inline]
-    fn next(&mut self) -> Option<(A, B)> {
+    fn next(&mut self) -> Option<(T, U)> {
         match self.a.next() {
             None => None,
             Some(x) => match self.b.next() {
@@ -1401,10 +1463,12 @@ impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for Zip<T, U> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, T: ExactSizeIterator<A>, U: ExactSizeIterator<B>> DoubleEndedIterator<(A, B)>
-for Zip<T, U> {
+impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
+    A: ExactSizeIterator + Iterator<Item=T>,
+    B: ExactSizeIterator + Iterator<Item=U>,
+{
     #[inline]
-    fn next_back(&mut self) -> Option<(A, B)> {
+    fn next_back(&mut self) -> Option<(T, U)> {
         let a_sz = self.a.len();
         let b_sz = self.b.len();
         if a_sz != b_sz {
@@ -1424,15 +1488,17 @@ for Zip<T, U> {
 }
 
 #[experimental = "trait is experimental"]
-impl<A, B, T: RandomAccessIterator<A>, U: RandomAccessIterator<B>>
-RandomAccessIterator<(A, B)> for Zip<T, U> {
+impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
+    A: RandomAccessIterator + Iterator<Item=T>,
+    B: RandomAccessIterator + Iterator<Item=U>,
+{
     #[inline]
     fn indexable(&self) -> uint {
         cmp::min(self.a.indexable(), self.b.indexable())
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<(A, B)> {
+    fn idx(&mut self, index: uint) -> Option<(T, U)> {
         match self.a.idx(index) {
             None => None,
             Some(x) => match self.b.idx(index) {
@@ -1446,7 +1512,7 @@ RandomAccessIterator<(A, B)> for Zip<T, U> {
 /// An iterator that maps the values of `iter` with `f`
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Map<A, B, I: Iterator<A>, F: FnMut(A) -> B> {
+pub struct Map<A, B, I: Iterator<Item=A>, F: FnMut(A) -> B> {
     iter: I,
     f: F,
 }
@@ -1454,7 +1520,7 @@ pub struct Map<A, B, I: Iterator<A>, F: FnMut(A) -> B> {
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, B, I, F> Clone for Map<A, B, I, F> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     F: Clone + FnMut(A) -> B,
 {
     fn clone(&self) -> Map<A, B, I, F> {
@@ -1465,7 +1531,7 @@ impl<A, B, I, F> Clone for Map<A, B, I, F> where
     }
 }
 
-impl<A, B, I, F> Map<A, B, I, F> where I: Iterator<A>, F: FnMut(A) -> B {
+impl<A, B, I, F> Map<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> B {
     #[inline]
     fn do_map(&mut self, elt: Option<A>) -> Option<B> {
         match elt {
@@ -1476,7 +1542,9 @@ impl<A, B, I, F> Map<A, B, I, F> where I: Iterator<A>, F: FnMut(A) -> B {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, F> Iterator<B> for Map<A, B, I, F> where I: Iterator<A>, F: FnMut(A) -> B {
+impl<A, B, I, F> Iterator for Map<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> B {
+    type Item = B;
+
     #[inline]
     fn next(&mut self) -> Option<B> {
         let next = self.iter.next();
@@ -1490,8 +1558,8 @@ impl<A, B, I, F> Iterator<B> for Map<A, B, I, F> where I: Iterator<A>, F: FnMut(
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, F> DoubleEndedIterator<B> for Map<A, B, I, F> where
-    I: DoubleEndedIterator<A>,
+impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
+    I: DoubleEndedIterator + Iterator<Item=A>,
     F: FnMut(A) -> B,
 {
     #[inline]
@@ -1502,8 +1570,8 @@ impl<A, B, I, F> DoubleEndedIterator<B> for Map<A, B, I, F> where
 }
 
 #[experimental = "trait is experimental"]
-impl<A, B, I, F> RandomAccessIterator<B> for Map<A, B, I, F> where
-    I: RandomAccessIterator<A>,
+impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
+    I: RandomAccessIterator + Iterator<Item=A>,
     F: FnMut(A) -> B,
 {
     #[inline]
@@ -1521,7 +1589,7 @@ impl<A, B, I, F> RandomAccessIterator<B> for Map<A, B, I, F> where
 /// An iterator that filters the elements of `iter` with `predicate`
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Filter<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+pub struct Filter<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
     iter: I,
     predicate: P,
 }
@@ -1529,7 +1597,7 @@ pub struct Filter<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, I, P> Clone for Filter<A, I, P> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     P: Clone + FnMut(&A) -> bool,
 {
     fn clone(&self) -> Filter<A, I, P> {
@@ -1541,7 +1609,9 @@ impl<A, I, P> Clone for Filter<A, I, P> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, P> Iterator<A> for Filter<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+impl<A, I, P> Iterator for Filter<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         for x in self.iter {
@@ -1562,8 +1632,8 @@ impl<A, I, P> Iterator<A> for Filter<A, I, P> where I: Iterator<A>, P: FnMut(&A)
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, P> DoubleEndedIterator<A> for Filter<A, I, P> where
-    I: DoubleEndedIterator<A>,
+impl<A, I, P> DoubleEndedIterator for Filter<A, I, P> where
+    I: DoubleEndedIterator + Iterator<Item=A>,
     P: FnMut(&A) -> bool,
 {
     #[inline]
@@ -1580,7 +1650,7 @@ impl<A, I, P> DoubleEndedIterator<A> for Filter<A, I, P> where
 /// An iterator that uses `f` to both filter and map elements from `iter`
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct FilterMap<A, B, I, F> where I: Iterator<A>, F: FnMut(A) -> Option<B> {
+pub struct FilterMap<A, B, I, F> where I: Iterator<Item=A>, F: FnMut(A) -> Option<B> {
     iter: I,
     f: F,
 }
@@ -1588,7 +1658,7 @@ pub struct FilterMap<A, B, I, F> where I: Iterator<A>, F: FnMut(A) -> Option<B>
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, B, I, F> Clone for FilterMap<A, B, I, F> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     F: Clone + FnMut(A) -> Option<B>,
 {
     fn clone(&self) -> FilterMap<A, B, I, F> {
@@ -1600,10 +1670,12 @@ impl<A, B, I, F> Clone for FilterMap<A, B, I, F> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, F> Iterator<B> for FilterMap<A, B, I, F> where
-    I: Iterator<A>,
+impl<A, B, I, F> Iterator for FilterMap<A, B, I, F> where
+    I: Iterator<Item=A>,
     F: FnMut(A) -> Option<B>,
 {
+    type Item = B;
+
     #[inline]
     fn next(&mut self) -> Option<B> {
         for x in self.iter {
@@ -1623,8 +1695,8 @@ impl<A, B, I, F> Iterator<B> for FilterMap<A, B, I, F> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, F> DoubleEndedIterator<B> for FilterMap<A, B, I, F> where
-    I: DoubleEndedIterator<A>,
+impl<A, B, I, F> DoubleEndedIterator for FilterMap<A, B, I, F> where
+    I: DoubleEndedIterator + Iterator<Item=A>,
     F: FnMut(A) -> Option<B>,
 {
     #[inline]
@@ -1643,15 +1715,17 @@ impl<A, B, I, F> DoubleEndedIterator<B> for FilterMap<A, B, I, F> where
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Enumerate<T> {
-    iter: T,
+pub struct Enumerate<I> {
+    iter: I,
     count: uint
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: Iterator<A>> Iterator<(uint, A)> for Enumerate<T> {
+impl<I> Iterator for Enumerate<I> where I: Iterator {
+    type Item = (uint, <I as Iterator>::Item);
+
     #[inline]
-    fn next(&mut self) -> Option<(uint, A)> {
+    fn next(&mut self) -> Option<(uint, <I as Iterator>::Item)> {
         match self.iter.next() {
             Some(a) => {
                 let ret = Some((self.count, a));
@@ -1669,9 +1743,9 @@ impl<A, T: Iterator<A>> Iterator<(uint, A)> for Enumerate<T> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: ExactSizeIterator<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> {
+impl<I> DoubleEndedIterator for Enumerate<I> where I: ExactSizeIterator {
     #[inline]
-    fn next_back(&mut self) -> Option<(uint, A)> {
+    fn next_back(&mut self) -> Option<(uint, <I as Iterator>::Item)> {
         match self.iter.next_back() {
             Some(a) => {
                 let len = self.iter.len();
@@ -1683,14 +1757,14 @@ impl<A, T: ExactSizeIterator<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T>
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<(uint, A)> for Enumerate<T> {
+impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint {
         self.iter.indexable()
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<(uint, A)> {
+    fn idx(&mut self, index: uint) -> Option<(uint, <I as Iterator>::Item)> {
         match self.iter.idx(index) {
             Some(a) => Some((self.count + index, a)),
             _ => None,
@@ -1702,14 +1776,16 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<(uint, A)> for Enumerat
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
 #[deriving(Copy)]
-pub struct Peekable<A, T> {
-    iter: T,
-    peeked: Option<A>,
+pub struct Peekable<T, I> where I: Iterator<Item=T> {
+    iter: I,
+    peeked: Option<T>,
 }
 
-impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> {
+impl<T, I> Iterator for Peekable<T, I> where I: Iterator<Item=T> {
+    type Item = T;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option<T> {
         if self.peeked.is_some() { self.peeked.take() }
         else { self.iter.next() }
     }
@@ -1731,11 +1807,11 @@ impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> {
 }
 
 #[stable]
-impl<'a, A, T: Iterator<A>> Peekable<A, T> {
+impl<T, I> Peekable<T, I> where I: Iterator<Item=T> {
     /// Return a reference to the next element of the iterator with out advancing it,
     /// or None if the iterator is exhausted.
     #[inline]
-    pub fn peek(&'a mut self) -> Option<&'a A> {
+    pub fn peek(&mut self) -> Option<&T> {
         if self.peeked.is_none() {
             self.peeked = self.iter.next();
         }
@@ -1755,7 +1831,7 @@ impl<'a, A, T: Iterator<A>> Peekable<A, T> {
 /// An iterator that rejects elements while `predicate` is true
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct SkipWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+pub struct SkipWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
     iter: I,
     flag: bool,
     predicate: P,
@@ -1764,7 +1840,7 @@ pub struct SkipWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, I, P> Clone for SkipWhile<A, I, P> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     P: Clone + FnMut(&A) -> bool,
 {
     fn clone(&self) -> SkipWhile<A, I, P> {
@@ -1777,7 +1853,9 @@ impl<A, I, P> Clone for SkipWhile<A, I, P> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, P> Iterator<A> for SkipWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+impl<A, I, P> Iterator for SkipWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         for x in self.iter {
@@ -1799,7 +1877,7 @@ impl<A, I, P> Iterator<A> for SkipWhile<A, I, P> where I: Iterator<A>, P: FnMut(
 /// An iterator that only accepts elements while `predicate` is true
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct TakeWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+pub struct TakeWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
     iter: I,
     flag: bool,
     predicate: P,
@@ -1808,7 +1886,7 @@ pub struct TakeWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, I, P> Clone for TakeWhile<A, I, P> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     P: Clone + FnMut(&A) -> bool,
 {
     fn clone(&self) -> TakeWhile<A, I, P> {
@@ -1821,7 +1899,9 @@ impl<A, I, P> Clone for TakeWhile<A, I, P> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, P> Iterator<A> for TakeWhile<A, I, P> where I: Iterator<A>, P: FnMut(&A) -> bool {
+impl<A, I, P> Iterator for TakeWhile<A, I, P> where I: Iterator<Item=A>, P: FnMut(&A) -> bool {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.flag {
@@ -1852,15 +1932,17 @@ impl<A, I, P> Iterator<A> for TakeWhile<A, I, P> where I: Iterator<A>, P: FnMut(
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Skip<T> {
-    iter: T,
+pub struct Skip<I> {
+    iter: I,
     n: uint
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: Iterator<A>> Iterator<A> for Skip<T> {
+impl<I> Iterator for Skip<I> where I: Iterator {
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option< <I as Iterator>::Item> {
         let mut next = self.iter.next();
         if self.n == 0 {
             next
@@ -1900,14 +1982,14 @@ impl<A, T: Iterator<A>> Iterator<A> for Skip<T> {
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Skip<T> {
+impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> uint {
         self.iter.indexable().saturating_sub(self.n)
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
         if index >= self.indexable() {
             None
         } else {
@@ -1920,15 +2002,17 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Skip<T> {
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Take<T> {
-    iter: T,
+pub struct Take<I> {
+    iter: I,
     n: uint
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: Iterator<A>> Iterator<A> for Take<T> {
+impl<I> Iterator for Take<I> where I: Iterator{
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option< <I as Iterator>::Item> {
         if self.n != 0 {
             self.n -= 1;
             self.iter.next()
@@ -1953,14 +2037,14 @@ impl<A, T: Iterator<A>> Iterator<A> for Take<T> {
 }
 
 #[experimental = "trait is experimental"]
-impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Take<T> {
+impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> uint {
         cmp::min(self.iter.indexable(), self.n)
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
         if index >= self.n {
             None
         } else {
@@ -1973,7 +2057,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Take<T> {
 /// An iterator to maintain state while iterating another iterator
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[unstable = "waiting for unboxed closures"]
-pub struct Scan<A, B, I, St, F> where I: Iterator<A>, F: FnMut(&mut St, A) -> Option<B> {
+pub struct Scan<A, B, I, St, F> where I: Iterator, F: FnMut(&mut St, A) -> Option<B> {
     iter: I,
     f: F,
 
@@ -1984,7 +2068,7 @@ pub struct Scan<A, B, I, St, F> where I: Iterator<A>, F: FnMut(&mut St, A) -> Op
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, B, I, St, F> Clone for Scan<A, B, I, St, F> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     St: Clone,
     F: Clone + FnMut(&mut St, A) -> Option<B>,
 {
@@ -1998,10 +2082,12 @@ impl<A, B, I, St, F> Clone for Scan<A, B, I, St, F> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, St, F> Iterator<B> for Scan<A, B, I, St, F> where
-    I: Iterator<A>,
+impl<A, B, I, St, F> Iterator for Scan<A, B, I, St, F> where
+    I: Iterator<Item=A>,
     F: FnMut(&mut St, A) -> Option<B>,
 {
+    type Item = B;
+
     #[inline]
     fn next(&mut self) -> Option<B> {
         self.iter.next().and_then(|a| (self.f)(&mut self.state, a))
@@ -2019,7 +2105,11 @@ impl<A, B, I, St, F> Iterator<B> for Scan<A, B, I, St, F> where
 ///
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[unstable = "waiting for unboxed closures"]
-pub struct FlatMap<A, B, I, U, F> where I: Iterator<A>, U: Iterator<B>, F: FnMut(A) -> U {
+pub struct FlatMap<A, B, I, U, F> where
+    I: Iterator<Item=A>,
+    U: Iterator<Item=B>,
+    F: FnMut(A) -> U,
+{
     iter: I,
     f: F,
     frontiter: Option<U>,
@@ -2029,8 +2119,8 @@ pub struct FlatMap<A, B, I, U, F> where I: Iterator<A>, U: Iterator<B>, F: FnMut
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, B, I, U, F> Clone for FlatMap<A, B, I, U, F> where
-    I: Clone + Iterator<A>,
-    U: Clone + Iterator<B>,
+    I: Clone + Iterator<Item=A>,
+    U: Clone + Iterator<Item=B>,
     F: Clone + FnMut(A) -> U,
 {
     fn clone(&self) -> FlatMap<A, B, I, U, F> {
@@ -2044,11 +2134,13 @@ impl<A, B, I, U, F> Clone for FlatMap<A, B, I, U, F> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, U, F> Iterator<B> for FlatMap<A, B, I, U, F> where
-    I: Iterator<A>,
-    U: Iterator<B>,
+impl<A, B, I, U, F> Iterator for FlatMap<A, B, I, U, F> where
+    I: Iterator<Item=A>,
+    U: Iterator<Item=B>,
     F: FnMut(A) -> U,
 {
+    type Item = B;
+
     #[inline]
     fn next(&mut self) -> Option<B> {
         loop {
@@ -2077,9 +2169,9 @@ impl<A, B, I, U, F> Iterator<B> for FlatMap<A, B, I, U, F> where
 }
 
 #[unstable = "trait is unstable"]
-impl<A, B, I, U, F> DoubleEndedIterator<B> for FlatMap<A, B, I, U, F> where
-    I: DoubleEndedIterator<A>,
-    U: DoubleEndedIterator<B>,
+impl<A, B, I, U, F> DoubleEndedIterator for FlatMap<A, B, I, U, F> where
+    I: DoubleEndedIterator + Iterator<Item=A>,
+    U: DoubleEndedIterator + Iterator<Item=B>,
     F: FnMut(A) -> U,
 {
     #[inline]
@@ -2104,15 +2196,17 @@ impl<A, B, I, U, F> DoubleEndedIterator<B> for FlatMap<A, B, I, U, F> where
 #[deriving(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable]
-pub struct Fuse<T> {
-    iter: T,
+pub struct Fuse<I> {
+    iter: I,
     done: bool
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: Iterator<A>> Iterator<A> for Fuse<T> {
+impl<I> Iterator for Fuse<I> where I: Iterator {
+    type Item = <I as Iterator>::Item;
+
     #[inline]
-    fn next(&mut self) -> Option<A> {
+    fn next(&mut self) -> Option< <I as Iterator>::Item> {
         if self.done {
             None
         } else {
@@ -2137,9 +2231,9 @@ impl<A, T: Iterator<A>> Iterator<A> for Fuse<T> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Fuse<T> {
+impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
     #[inline]
-    fn next_back(&mut self) -> Option<A> {
+    fn next_back(&mut self) -> Option< <I as Iterator>::Item> {
         if self.done {
             None
         } else {
@@ -2156,20 +2250,20 @@ impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Fuse<T> {
 
 // Allow RandomAccessIterators to be fused without affecting random-access behavior
 #[experimental = "trait is experimental"]
-impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Fuse<T> {
+impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint {
         self.iter.indexable()
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<A> {
+    fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
         self.iter.idx(index)
     }
 }
 
 #[experimental = "seems marginal"]
-impl<T> Fuse<T> {
+impl<I> Fuse<I> {
     /// Resets the fuse such that the next call to .next() or .next_back() will
     /// call the underlying iterator again even if it previously returned None.
     #[inline]
@@ -2182,7 +2276,7 @@ impl<T> Fuse<T> {
 /// element before yielding it.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[unstable = "waiting for unboxed closures"]
-pub struct Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A) {
+pub struct Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
     iter: I,
     f: F,
 }
@@ -2190,7 +2284,7 @@ pub struct Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A) {
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
 #[stable]
 impl<A, I, F> Clone for Inspect<A, I, F> where
-    I: Clone + Iterator<A>,
+    I: Clone + Iterator<Item=A>,
     F: Clone + FnMut(&A),
 {
     fn clone(&self) -> Inspect<A, I, F> {
@@ -2201,7 +2295,7 @@ impl<A, I, F> Clone for Inspect<A, I, F> where
     }
 }
 
-impl<A, I, F> Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A) {
+impl<A, I, F> Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
     #[inline]
     fn do_inspect(&mut self, elt: Option<A>) -> Option<A> {
         match elt {
@@ -2214,7 +2308,9 @@ impl<A, I, F> Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A) {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, F> Iterator<A> for Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A) {
+impl<A, I, F> Iterator for Inspect<A, I, F> where I: Iterator<Item=A>, F: FnMut(&A) {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         let next = self.iter.next();
@@ -2228,8 +2324,8 @@ impl<A, I, F> Iterator<A> for Inspect<A, I, F> where I: Iterator<A>, F: FnMut(&A
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I, F> DoubleEndedIterator<A> for Inspect<A, I, F> where
-    I: DoubleEndedIterator<A>,
+impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
+    I: DoubleEndedIterator + Iterator<Item=A>,
     F: FnMut(&A),
 {
     #[inline]
@@ -2240,8 +2336,8 @@ impl<A, I, F> DoubleEndedIterator<A> for Inspect<A, I, F> where
 }
 
 #[experimental = "trait is experimental"]
-impl<A, I, F> RandomAccessIterator<A> for Inspect<A, I, F> where
-    I: RandomAccessIterator<A>,
+impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
+    I: RandomAccessIterator + Iterator<Item=A>,
     F: FnMut(&A),
 {
     #[inline]
@@ -2323,7 +2419,9 @@ impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
 }
 
 #[experimental]
-impl<A, St, F> Iterator<A> for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
+impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         (self.f)(&mut self.state)
@@ -2355,7 +2453,9 @@ pub fn count<A>(start: A, step: A) -> Counter<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
+impl<A: Add<A, A> + Clone> Iterator for Counter<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         let result = self.state.clone();
@@ -2402,7 +2502,9 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
 
 // FIXME: #10414: Unfortunate type bound
 #[unstable = "trait is unstable"]
-impl<A: Int + ToPrimitive> Iterator<A> for Range<A> {
+impl<A: Int + ToPrimitive> Iterator for Range<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.state < self.stop {
@@ -2450,7 +2552,7 @@ impl<A: Int + ToPrimitive> Iterator<A> for Range<A> {
 /// `Int` is required to ensure the range will be the same regardless of
 /// the direction it is consumed.
 #[unstable = "trait is unstable"]
-impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for Range<A> {
+impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.stop > self.state {
@@ -2481,7 +2583,9 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Int + ToPrimitive> Iterator<A> for RangeInclusive<A> {
+impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         match self.range.next() {
@@ -2514,7 +2618,7 @@ impl<A: Int + ToPrimitive> Iterator<A> for RangeInclusive<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for RangeInclusive<A> {
+impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.range.stop > self.range.state {
@@ -2549,7 +2653,9 @@ pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Int> Iterator<A> for RangeStep<A> {
+impl<A: Int> Iterator for RangeStep<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
@@ -2591,7 +2697,9 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Int> Iterator<A> for RangeStepInclusive<A> {
+impl<A: Int> Iterator for RangeStepInclusive<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         if !self.done && ((self.rev && self.state >= self.stop) ||
@@ -2683,7 +2791,9 @@ impl<A: Clone> Repeat<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Clone> Iterator<A> for Repeat<A> {
+impl<A: Clone> Iterator for Repeat<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> { self.idx(0) }
     #[inline]
@@ -2691,13 +2801,13 @@ impl<A: Clone> Iterator<A> for Repeat<A> {
 }
 
 #[unstable = "trait is unstable"]
-impl<A: Clone> DoubleEndedIterator<A> for Repeat<A> {
+impl<A: Clone> DoubleEndedIterator for Repeat<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> { self.idx(0) }
 }
 
 #[experimental = "trait is experimental"]
-impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
+impl<A: Clone> RandomAccessIterator for Repeat<A> {
     #[inline]
     fn indexable(&self) -> uint { uint::MAX }
     #[inline]
@@ -2766,7 +2876,11 @@ pub mod order {
     use super::Iterator;
 
     /// Compare `a` and `b` for equality using `Eq`
-    pub fn equals<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn equals<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: Eq,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2777,7 +2891,11 @@ pub mod order {
     }
 
     /// Order `a` and `b` lexicographically using `Ord`
-    pub fn cmp<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering {
+    pub fn cmp<A, T, S>(mut a: T, mut b: S) -> cmp::Ordering where
+        A: Ord,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return Equal,
@@ -2792,8 +2910,11 @@ pub mod order {
     }
 
     /// Order `a` and `b` lexicographically using `PartialOrd`
-    pub fn partial_cmp<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S)
-            -> Option<cmp::Ordering> {
+    pub fn partial_cmp<A, T, S>(mut a: T, mut b: S) -> Option<cmp::Ordering> where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return Some(Equal),
@@ -2810,8 +2931,8 @@ pub mod order {
     /// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
     pub fn eq<A, B, L, R>(mut a: L, mut b: R) -> bool where
         A: PartialEq<B>,
-        L: Iterator<A>,
-        R: Iterator<B>,
+        L: Iterator<Item=A>,
+        R: Iterator<Item=B>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2825,8 +2946,8 @@ pub mod order {
     /// Compare `a` and `b` for nonequality (Using partial equality, `PartialEq`)
     pub fn ne<A, B, L, R>(mut a: L, mut b: R) -> bool where
         A: PartialEq<B>,
-        L: Iterator<A>,
-        R: Iterator<B>,
+        L: Iterator<Item=A>,
+        R: Iterator<Item=B>,
     {
         loop {
             match (a.next(), b.next()) {
@@ -2838,7 +2959,11 @@ pub mod order {
     }
 
     /// Return `a` < `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn lt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn lt<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return false,
@@ -2850,7 +2975,11 @@ pub mod order {
     }
 
     /// Return `a` <= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn le<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn le<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
@@ -2862,7 +2991,11 @@ pub mod order {
     }
 
     /// Return `a` > `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn gt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn gt<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return false,
@@ -2874,7 +3007,11 @@ pub mod order {
     }
 
     /// Return `a` >= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn ge<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
+    pub fn ge<A, T, S>(mut a: T, mut b: S) -> bool where
+        A: PartialOrd,
+        T: Iterator<Item=A>,
+        S: Iterator<Item=A>,
+    {
         loop {
             match (a.next(), b.next()) {
                 (None, None) => return true,
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index b51d4d91c2f55..c5441359ad0c4 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -789,7 +789,9 @@ pub struct Range<Idx> {
 
 // FIXME(#19391) needs a snapshot
 //impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
-impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
+impl<Idx: Clone + Step> Iterator for Range<Idx> {
+    type Item = Idx;
+
     #[inline]
     fn next(&mut self) -> Option<Idx> {
         if self.start < self.end {
@@ -811,7 +813,7 @@ impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
     }
 }
 
-impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
+impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     #[inline]
     fn next_back(&mut self) -> Option<Idx> {
         if self.start < self.end {
@@ -823,7 +825,7 @@ impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
     }
 }
 
-impl<Idx: Clone + Step> ExactSizeIterator<Idx> for Range<Idx> {}
+impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
 
 /// A range which is only bounded below.
 #[deriving(Copy)]
@@ -833,7 +835,9 @@ pub struct RangeFrom<Idx> {
     pub start: Idx,
 }
 
-impl<Idx: Clone + Step> Iterator<Idx> for RangeFrom<Idx> {
+impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
+    type Item = Idx;
+
     #[inline]
     fn next(&mut self) -> Option<Idx> {
         // Deliberately overflow so we loop forever.
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index b9749f57d5832..92209b937d927 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -777,7 +777,9 @@ struct Item<A> {
     opt: Option<A>
 }
 
-impl<A> Iterator<A> for Item<A> {
+impl<A> Iterator for Item<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> {
         self.opt.take()
@@ -792,32 +794,34 @@ impl<A> Iterator<A> for Item<A> {
     }
 }
 
-impl<A> DoubleEndedIterator<A> for Item<A> {
+impl<A> DoubleEndedIterator for Item<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         self.opt.take()
     }
 }
 
-impl<A> ExactSizeIterator<A> for Item<A> {}
+impl<A> ExactSizeIterator for Item<A> {}
 
 /// An iterator over a reference of the contained item in an Option.
 #[stable]
 pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
 
-impl<'a, A> Iterator<&'a A> for Iter<'a, A> {
+impl<'a, A> Iterator for Iter<'a, A> {
+    type Item = &'a A;
+
     #[inline]
     fn next(&mut self) -> Option<&'a A> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
-impl<'a, A> DoubleEndedIterator<&'a A> for Iter<'a, A> {
+impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
 }
 
-impl<'a, A> ExactSizeIterator<&'a A> for Iter<'a, A> {}
+impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
 
 #[stable]
 impl<'a, A> Clone for Iter<'a, A> {
@@ -830,37 +834,41 @@ impl<'a, A> Clone for Iter<'a, A> {
 #[stable]
 pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
 
-impl<'a, A> Iterator<&'a mut A> for IterMut<'a, A> {
+impl<'a, A> Iterator for IterMut<'a, A> {
+    type Item = &'a mut A;
+
     #[inline]
     fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
-impl<'a, A> DoubleEndedIterator<&'a mut A> for IterMut<'a, A> {
+impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
 }
 
-impl<'a, A> ExactSizeIterator<&'a mut A> for IterMut<'a, A> {}
+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> }
 
-impl<A> Iterator<A> for IntoIter<A> {
+impl<A> Iterator for IntoIter<A> {
+    type Item = A;
+
     #[inline]
     fn next(&mut self) -> Option<A> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
-impl<A> DoubleEndedIterator<A> for IntoIter<A> {
+impl<A> DoubleEndedIterator for IntoIter<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
 }
 
-impl<A> ExactSizeIterator<A> for IntoIter<A> {}
+impl<A> ExactSizeIterator for IntoIter<A> {}
 
 /////////////////////////////////////////////////////////////////////////////
 // FromIterator
@@ -887,7 +895,7 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
     /// ```
     #[inline]
     #[stable]
-    fn from_iter<I: Iterator<Option<A>>>(iter: I) -> Option<V> {
+    fn from_iter<I: Iterator<Item=Option<A>>>(iter: I) -> Option<V> {
         // FIXME(#11084): This could be replaced with Iterator::scan when this
         // performance bug is closed.
 
@@ -896,7 +904,9 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
             found_none: bool,
         }
 
-        impl<T, Iter: Iterator<Option<T>>> Iterator<T> for Adapter<Iter> {
+        impl<T, Iter: Iterator<Item=Option<T>>> Iterator for Adapter<Iter> {
+            type Item = T;
+
             #[inline]
             fn next(&mut self) -> Option<T> {
                 match self.iter.next() {
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index 8cb631380095f..1355825e56dfd 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -42,9 +42,9 @@ pub use char::Char;
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use iter::{Extend, IteratorExt};
-pub use iter::{Iterator, DoubleEndedIterator, DoubleEndedIteratorExt};
+pub use iter::{Iterator, DoubleEndedIterator};
 pub use iter::{IteratorCloneExt, CloneIteratorExt};
-pub use iter::{IteratorOrdExt, ExactSizeIterator, IteratorPairExt};
+pub use iter::{IteratorOrdExt, ExactSizeIterator};
 pub use option::Option::{mod, Some, None};
 pub use ptr::{PtrExt, MutPtrExt};
 pub use result::Result::{mod, Ok, Err};
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index bd1c6dbcf1e9a..b0ee5672e060d 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -807,7 +807,9 @@ impl<T, E> AsSlice<T> for Result<T, E> {
 #[stable]
 pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
 
-impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
     #[inline]
     fn next(&mut self) -> Option<&'a T> { self.inner.take() }
     #[inline]
@@ -817,12 +819,12 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
 }
 
-impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } }
@@ -832,7 +834,9 @@ impl<'a, T> Clone for Iter<'a, T> {
 #[stable]
 pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
 
-impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
+impl<'a, T> Iterator for IterMut<'a, T> {
+    type Item = &'a mut T;
+
     #[inline]
     fn next(&mut self) -> Option<&'a mut T> { self.inner.take() }
     #[inline]
@@ -842,18 +846,20 @@ impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator<&'a mut T> for IterMut<'a, T> {
+impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
 }
 
-impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
+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> }
 
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     #[inline]
     fn next(&mut self) -> Option<T> { self.inner.take() }
     #[inline]
@@ -863,12 +869,12 @@ impl<T> Iterator<T> for IntoIter<T> {
     }
 }
 
-impl<T> DoubleEndedIterator<T> for IntoIter<T> {
+impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> { self.inner.take() }
 }
 
-impl<T> ExactSizeIterator<T> for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /////////////////////////////////////////////////////////////////////////////
 // FromIterator
@@ -894,7 +900,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
     /// assert!(res == Ok(vec!(2u, 3u)));
     /// ```
     #[inline]
-    fn from_iter<I: Iterator<Result<A, E>>>(iter: I) -> Result<V, E> {
+    fn from_iter<I: Iterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
         // FIXME(#11084): This could be replaced with Iterator::scan when this
         // performance bug is closed.
 
@@ -903,7 +909,9 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
             err: Option<E>,
         }
 
-        impl<T, E, Iter: Iterator<Result<T, E>>> Iterator<T> for Adapter<Iter, E> {
+        impl<T, E, Iter: Iterator<Item=Result<T, E>>> Iterator for Adapter<Iter, E> {
+            type Item = T;
+
             #[inline]
             fn next(&mut self) -> Option<T> {
                 match self.iter.next() {
@@ -941,7 +949,7 @@ pub fn fold<T,
             V,
             E,
             F: FnMut(V, T) -> V,
-            Iter: Iterator<Result<T, E>>>(
+            Iter: Iterator<Item=Result<T, E>>>(
             mut iterator: Iter,
             mut init: V,
             mut f: F)
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 07addf7a56969..bc4e8d32887e2 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -647,7 +647,9 @@ impl<'a, T> Default for &'a [T] {
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {
         #[experimental = "needs review"]
-        impl<'a, T> Iterator<$elem> for $name<'a, T> {
+        impl<'a, T> Iterator for $name<'a, T> {
+            type Item = $elem;
+
             #[inline]
             fn next(&mut self) -> Option<$elem> {
                 // could be implemented with slices, but this avoids bounds checks
@@ -683,7 +685,7 @@ macro_rules! iterator {
         }
 
         #[experimental = "needs review"]
-        impl<'a, T> DoubleEndedIterator<$elem> for $name<'a, T> {
+        impl<'a, T> DoubleEndedIterator for $name<'a, T> {
             #[inline]
             fn next_back(&mut self) -> Option<$elem> {
                 // could be implemented with slices, but this avoids bounds checks
@@ -766,7 +768,7 @@ impl<'a,T> Copy for Iter<'a,T> {}
 iterator!{struct Iter -> *const T, &'a T}
 
 #[experimental = "needs review"]
-impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 #[stable]
 impl<'a, T> Clone for Iter<'a, T> {
@@ -774,7 +776,7 @@ impl<'a, T> Clone for Iter<'a, T> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> RandomAccessIterator<&'a T> for Iter<'a, T> {
+impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
         let (exact, _) = self.size_hint();
@@ -860,14 +862,14 @@ impl<'a, T> IterMut<'a, T> {
 iterator!{struct IterMut -> *mut T, &'a mut T}
 
 #[experimental = "needs review"]
-impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
+impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// An internal abstraction over the splitting iterators, so that
 /// splitn, splitn_mut etc can be implemented once.
-trait SplitIter<E>: DoubleEndedIterator<E> {
+trait SplitIter: DoubleEndedIterator {
     /// Mark the underlying iterator as complete, extracting the remaining
     /// portion of the slice.
-    fn finish(&mut self) -> Option<E>;
+    fn finish(&mut self) -> Option< <Self as Iterator>::Item>;
 }
 
 /// An iterator over subslices separated by elements that match a predicate
@@ -892,7 +894,9 @@ impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
 }
 
 #[experimental = "needs review"]
-impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
+impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
+    type Item = &'a [T];
+
     #[inline]
     fn next(&mut self) -> Option<&'a [T]> {
         if self.finished { return None; }
@@ -918,7 +922,7 @@ impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool
 }
 
 #[experimental = "needs review"]
-impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
+impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
         if self.finished { return None; }
@@ -934,7 +938,7 @@ impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&
     }
 }
 
-impl<'a, T, P> SplitIter<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
+impl<'a, T, P> SplitIter for Split<'a, T, P> where P: FnMut(&T) -> bool {
     #[inline]
     fn finish(&mut self) -> Option<&'a [T]> {
         if self.finished { None } else { self.finished = true; Some(self.v) }
@@ -950,7 +954,7 @@ pub struct SplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {
     finished: bool
 }
 
-impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
+impl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     #[inline]
     fn finish(&mut self) -> Option<&'a mut [T]> {
         if self.finished {
@@ -963,7 +967,9 @@ impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T)
 }
 
 #[experimental = "needs review"]
-impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
+impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
+    type Item = &'a mut [T];
+
     #[inline]
     fn next(&mut self) -> Option<&'a mut [T]> {
         if self.finished { return None; }
@@ -996,7 +1002,7 @@ impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -
 }
 
 #[experimental = "needs review"]
-impl<'a, T, P> DoubleEndedIterator<&'a mut [T]> for SplitMut<'a, T, P> where
+impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
     P: FnMut(&T) -> bool,
 {
     #[inline]
@@ -1029,9 +1035,11 @@ struct GenericSplitN<I> {
 }
 
 #[experimental = "needs review"]
-impl<E, I: SplitIter<E>> Iterator<E> for GenericSplitN<I> {
+impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
+    type Item = T;
+
     #[inline]
-    fn next(&mut self) -> Option<E> {
+    fn next(&mut self) -> Option<T> {
         if self.count == 0 {
             self.iter.finish()
         } else {
@@ -1075,9 +1083,11 @@ pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
 
 macro_rules! forward_iterator {
     ($name:ident: $elem:ident, $iter_of:ty) => {
-        impl<'a, $elem, P> Iterator<$iter_of> for $name<'a, $elem, P> where
+        impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
             P: FnMut(&T) -> bool
         {
+            type Item = $iter_of;
+
             #[inline]
             fn next(&mut self) -> Option<$iter_of> {
                 self.inner.next()
@@ -1104,7 +1114,9 @@ pub struct Windows<'a, T:'a> {
     size: uint
 }
 
-impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
+impl<'a, T> Iterator for Windows<'a, T> {
+    type Item = &'a [T];
+
     #[inline]
     fn next(&mut self) -> Option<&'a [T]> {
         if self.size > self.v.len() {
@@ -1140,7 +1152,9 @@ pub struct Chunks<'a, T:'a> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
+impl<'a, T> Iterator for Chunks<'a, T> {
+    type Item = &'a [T];
+
     #[inline]
     fn next(&mut self) -> Option<&'a [T]> {
         if self.v.len() == 0 {
@@ -1167,7 +1181,7 @@ impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
+impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
         if self.v.len() == 0 {
@@ -1183,7 +1197,7 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
+impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
         self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
@@ -1213,7 +1227,9 @@ pub struct ChunksMut<'a, T:'a> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
+impl<'a, T> Iterator for ChunksMut<'a, T> {
+    type Item = &'a mut [T];
+
     #[inline]
     fn next(&mut self) -> Option<&'a mut [T]> {
         if self.v.len() == 0 {
@@ -1241,7 +1257,7 @@ impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
 }
 
 #[experimental = "needs review"]
-impl<'a, T> DoubleEndedIterator<&'a mut [T]> for ChunksMut<'a, T> {
+impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut [T]> {
         if self.v.len() == 0 {
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index f4fe86a0d7ec0..7e99e4236083e 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -21,7 +21,7 @@ use self::Searcher::{Naive, TwoWay, TwoWayLong};
 use cmp::{mod, Eq};
 use default::Default;
 use iter::range;
-use iter::{DoubleEndedIteratorExt, ExactSizeIterator};
+use iter::ExactSizeIterator;
 use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
 use kinds::Sized;
 use mem;
@@ -37,7 +37,7 @@ use uint;
 macro_rules! delegate_iter {
     (exact $te:ty in $ti:ty) => {
         delegate_iter!{$te in $ti}
-        impl<'a> ExactSizeIterator<$te> for $ti {
+        impl<'a> ExactSizeIterator for $ti {
             #[inline]
             fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
                 self.0.rposition(predicate)
@@ -49,7 +49,9 @@ macro_rules! delegate_iter {
         }
     };
     ($te:ty in $ti:ty) => {
-        impl<'a> Iterator<$te> for $ti {
+        impl<'a> Iterator for $ti {
+            type Item = $te;
+
             #[inline]
             fn next(&mut self) -> Option<$te> {
                 self.0.next()
@@ -59,7 +61,7 @@ macro_rules! delegate_iter {
                 self.0.size_hint()
             }
         }
-        impl<'a> DoubleEndedIterator<$te> for $ti {
+        impl<'a> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
                 self.0.next_back()
@@ -67,7 +69,9 @@ macro_rules! delegate_iter {
         }
     };
     (pattern $te:ty in $ti:ty) => {
-        impl<'a, P: CharEq> Iterator<$te> for $ti {
+        impl<'a, P: CharEq> Iterator for $ti {
+            type Item = $te;
+
             #[inline]
             fn next(&mut self) -> Option<$te> {
                 self.0.next()
@@ -77,7 +81,7 @@ macro_rules! delegate_iter {
                 self.0.size_hint()
             }
         }
-        impl<'a, P: CharEq> DoubleEndedIterator<$te> for $ti {
+        impl<'a, P: CharEq> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
                 self.0.next_back()
@@ -85,7 +89,9 @@ macro_rules! delegate_iter {
         }
     };
     (pattern forward $te:ty in $ti:ty) => {
-        impl<'a, P: CharEq> Iterator<$te> for $ti {
+        impl<'a, P: CharEq> Iterator for $ti {
+            type Item = $te;
+
             #[inline]
             fn next(&mut self) -> Option<$te> {
                 self.0.next()
@@ -275,7 +281,9 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
     }
 }
 
-impl<'a> Iterator<char> for Chars<'a> {
+impl<'a> Iterator for Chars<'a> {
+    type Item = char;
+
     #[inline]
     fn next(&mut self) -> Option<char> {
         // Decode UTF-8, using the valid UTF-8 invariant
@@ -318,7 +326,7 @@ impl<'a> Iterator<char> for Chars<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator<char> for Chars<'a> {
+impl<'a> DoubleEndedIterator for Chars<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
         let w = match self.iter.next_back() {
@@ -359,7 +367,9 @@ pub struct CharIndices<'a> {
     iter: Chars<'a>,
 }
 
-impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
+impl<'a> Iterator for CharIndices<'a> {
+    type Item = (uint, char);
+
     #[inline]
     fn next(&mut self) -> Option<(uint, char)> {
         let (pre_len, _) = self.iter.iter.size_hint();
@@ -380,7 +390,7 @@ impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator<(uint, char)> for CharIndices<'a> {
+impl<'a> DoubleEndedIterator for CharIndices<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<(uint, char)> {
         match self.iter.next_back() {
@@ -463,7 +473,9 @@ impl<'a, Sep> CharSplits<'a, Sep> {
     }
 }
 
-impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
+impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
+    type Item = &'a str;
+
     #[inline]
     fn next(&mut self) -> Option<&'a str> {
         if self.finished { return None }
@@ -495,8 +507,7 @@ impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
     }
 }
 
-impl<'a, Sep: CharEq> DoubleEndedIterator<&'a str>
-for CharSplits<'a, Sep> {
+impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> {
         if self.finished { return None }
@@ -537,7 +548,9 @@ for CharSplits<'a, Sep> {
     }
 }
 
-impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplitsN<'a, Sep> {
+impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
+    type Item = &'a str;
+
     #[inline]
     fn next(&mut self) -> Option<&'a str> {
         if self.count != 0 {
@@ -864,7 +877,9 @@ pub struct SplitStr<'a> {
 #[deprecated = "Type is now named `SplitStr`"]
 pub type StrSplits<'a> = SplitStr<'a>;
 
-impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
+impl<'a> Iterator for MatchIndices<'a> {
+    type Item = (uint, uint);
+
     #[inline]
     fn next(&mut self) -> Option<(uint, uint)> {
         match self.searcher {
@@ -878,7 +893,9 @@ impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
     }
 }
 
-impl<'a> Iterator<&'a str> for SplitStr<'a> {
+impl<'a> Iterator for SplitStr<'a> {
+    type Item = &'a str;
+
     #[inline]
     fn next(&mut self) -> Option<&'a str> {
         if self.finished { return None; }
@@ -1672,23 +1689,27 @@ impl<'a> Default for &'a str {
     fn default() -> &'a str { "" }
 }
 
-impl<'a> Iterator<&'a str> for Lines<'a> {
+impl<'a> Iterator for Lines<'a> {
+    type Item = &'a str;
+
     #[inline]
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
-impl<'a> DoubleEndedIterator<&'a str> for Lines<'a> {
+impl<'a> DoubleEndedIterator for Lines<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
 }
-impl<'a> Iterator<&'a str> for LinesAny<'a> {
+impl<'a> Iterator for LinesAny<'a> {
+    type Item = &'a str;
+
     #[inline]
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
-impl<'a> DoubleEndedIterator<&'a str> for LinesAny<'a> {
+impl<'a> DoubleEndedIterator for LinesAny<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
 }
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 7952c96a117cf..b53791f694480 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -561,7 +561,9 @@ fn test_rposition_panic() {
 
 
 #[cfg(test)]
-fn check_randacc_iter<A: PartialEq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint)
+fn check_randacc_iter<A, T>(a: T, len: uint) where
+    A: PartialEq,
+    T: Clone + RandomAccessIterator + Iterator<Item=A>,
 {
     let mut b = a.clone();
     assert_eq!(len, b.indexable());
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index c284fb7c9e338..ecb657b5a2ba5 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -24,6 +24,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![feature(macro_rules, globs, slicing_syntax)]
+#![feature(associated_types)]
 
 pub use self::Piece::*;
 pub use self::Position::*;
@@ -142,7 +143,9 @@ pub struct Parser<'a> {
     pub errors: Vec<string::String>,
 }
 
-impl<'a> Iterator<Piece<'a>> for Parser<'a> {
+impl<'a> Iterator for Parser<'a> {
+    type Item = Piece<'a>;
+
     fn next(&mut self) -> Option<Piece<'a>> {
         match self.cur.clone().next() {
             Some((pos, '{')) => {
diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs
index d0396ddc7adcc..901dffc04c5e9 100644
--- a/src/libgraphviz/maybe_owned_vec.rs
+++ b/src/libgraphviz/maybe_owned_vec.rs
@@ -124,7 +124,7 @@ impl<'b,T> AsSlice<T> for MaybeOwnedVector<'b,T> {
 
 impl<'a,T> FromIterator<T> for MaybeOwnedVector<'a,T> {
     #[allow(deprecated)]
-    fn from_iter<I:Iterator<T>>(iterator: I) -> MaybeOwnedVector<'a,T> {
+    fn from_iter<I:Iterator<Item=T>>(iterator: I) -> MaybeOwnedVector<'a,T> {
         // If we are building from scratch, might as well build the
         // most flexible variant.
         Growable(iterator.collect())
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index e96bf80feef6b..0f8dbc78cde32 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -25,6 +25,7 @@
 
 #![feature(macro_rules, phase, globs)]
 #![feature(unboxed_closures)]
+#![feature(associated_types)]
 #![no_std]
 #![experimental]
 
@@ -314,7 +315,9 @@ pub struct Generator<'a, T, R:'a> {
     rng: &'a mut R,
 }
 
-impl<'a, T: Rand, R: Rng> Iterator<T> for Generator<'a, T, R> {
+impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         Some(self.rng.gen())
     }
@@ -327,7 +330,9 @@ pub struct AsciiGenerator<'a, R:'a> {
     rng: &'a mut R,
 }
 
-impl<'a, R: Rng> Iterator<char> for AsciiGenerator<'a, R> {
+impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R> {
+    type Item = char;
+
     fn next(&mut self) -> Option<char> {
         static GEN_ASCII_STR_CHARSET: &'static [u8] =
             b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index 9ad02afee9934..c546477ee0152 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -373,6 +373,7 @@
 #![allow(unknown_features)]
 #![feature(macro_rules, phase, slicing_syntax, globs)]
 #![feature(unboxed_closures)]
+#![feature(associated_types)]
 #![deny(missing_docs)]
 
 #[cfg(test)]
diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index 3171966a596db..69c58eebd56d0 100644
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -546,7 +546,9 @@ pub enum NamesIter<'a> {
     NamesIterDynamic(::std::slice::Iter<'a, Option<String>>)
 }
 
-impl<'a> Iterator<Option<String>> for NamesIter<'a> {
+impl<'a> Iterator for NamesIter<'a> {
+    type Item = Option<String>;
+
     fn next(&mut self) -> Option<Option<String>> {
         match *self {
             NamesIterNative(ref mut i) => i.next().map(|x| x.map(|s| s.to_string())),
@@ -603,7 +605,9 @@ pub struct RegexSplits<'r, 't> {
     last: uint,
 }
 
-impl<'r, 't> Iterator<&'t str> for RegexSplits<'r, 't> {
+impl<'r, 't> Iterator for RegexSplits<'r, 't> {
+    type Item = &'t str;
+
     fn next(&mut self) -> Option<&'t str> {
         let text = self.finder.search;
         match self.finder.next() {
@@ -638,7 +642,9 @@ pub struct RegexSplitsN<'r, 't> {
     limit: uint,
 }
 
-impl<'r, 't> Iterator<&'t str> for RegexSplitsN<'r, 't> {
+impl<'r, 't> Iterator for RegexSplitsN<'r, 't> {
+    type Item = &'t str;
+
     fn next(&mut self) -> Option<&'t str> {
         let text = self.splits.finder.search;
         if self.cur >= self.limit {
@@ -801,7 +807,9 @@ pub struct SubCaptures<'t> {
     caps: &'t Captures<'t>,
 }
 
-impl<'t> Iterator<&'t str> for SubCaptures<'t> {
+impl<'t> Iterator for SubCaptures<'t> {
+    type Item = &'t str;
+
     fn next(&mut self) -> Option<&'t str> {
         if self.idx < self.caps.len() {
             self.idx += 1;
@@ -824,7 +832,9 @@ pub struct SubCapturesPos<'t> {
     caps: &'t Captures<'t>,
 }
 
-impl<'t> Iterator<Option<(uint, uint)>> for SubCapturesPos<'t> {
+impl<'t> Iterator for SubCapturesPos<'t> {
+    type Item = Option<(uint, uint)>;
+
     fn next(&mut self) -> Option<Option<(uint, uint)>> {
         if self.idx < self.caps.len() {
             self.idx += 1;
@@ -850,7 +860,9 @@ pub struct FindCaptures<'r, 't> {
     last_end: uint,
 }
 
-impl<'r, 't> Iterator<Captures<'t>> for FindCaptures<'r, 't> {
+impl<'r, 't> Iterator for FindCaptures<'r, 't> {
+    type Item = Captures<'t>;
+
     fn next(&mut self) -> Option<Captures<'t>> {
         if self.last_end > self.search.len() {
             return None
@@ -893,7 +905,9 @@ pub struct FindMatches<'r, 't> {
     last_end: uint,
 }
 
-impl<'r, 't> Iterator<(uint, uint)> for FindMatches<'r, 't> {
+impl<'r, 't> Iterator for FindMatches<'r, 't> {
+    type Item = (uint, uint);
+
     fn next(&mut self) -> Option<(uint, uint)> {
         if self.last_end > self.search.len() {
             return None
diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs
index 0baa5e6c24f22..ebd1cc7e166d7 100644
--- a/src/libregex_macros/lib.rs
+++ b/src/libregex_macros/lib.rs
@@ -603,7 +603,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
     // Converts `xs` to a `[x1, x2, .., xN]` expression by calling `to_expr`
     // on each element in `xs`.
     fn vec_expr<T, It, F>(&self, xs: It, mut to_expr: F) -> P<ast::Expr> where
-        It: Iterator<T>,
+        It: Iterator<Item=T>,
         F: FnMut(&ExtCtxt, T) -> P<ast::Expr>,
     {
         let exprs = xs.map(|x| to_expr(self.cx, x)).collect();
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index cdc27244dde6e..122171e469108 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -28,6 +28,7 @@
 #![feature(rustc_diagnostic_macros)]
 #![feature(unboxed_closures)]
 #![feature(old_orphan_check)]
+#![feature(associated_types)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 10383b901f38a..17663a127a881 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -364,7 +364,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
     }
 }
 
-fn encode_path<PI: Iterator<PathElem>>(rbml_w: &mut Encoder, path: PI) {
+fn encode_path<PI: Iterator<Item=PathElem>>(rbml_w: &mut Encoder, path: PI) {
     let path = path.collect::<Vec<_>>();
     rbml_w.start_tag(tag_path);
     rbml_w.wr_tagged_u32(tag_path_len, path.len() as u32);
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index 92aa70548c82b..a7b28a6323eaf 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -150,7 +150,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         }
     }
 
-    fn pats_all<'b, I: Iterator<&'b P<ast::Pat>>>(&mut self,
+    fn pats_all<'b, I: Iterator<Item=&'b P<ast::Pat>>>(&mut self,
                                           pats: I,
                                           pred: CFGIndex) -> CFGIndex {
         //! Handles case where all of the patterns must match.
@@ -501,7 +501,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         }
     }
 
-    fn call<'b, I: Iterator<&'b ast::Expr>>(&mut self,
+    fn call<'b, I: Iterator<Item=&'b ast::Expr>>(&mut self,
             call_expr: &ast::Expr,
             pred: CFGIndex,
             func_or_rcvr: &ast::Expr,
@@ -521,7 +521,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         }
     }
 
-    fn exprs<'b, I: Iterator<&'b ast::Expr>>(&mut self,
+    fn exprs<'b, I: Iterator<Item=&'b ast::Expr>>(&mut self,
                                              exprs: I,
                                              pred: CFGIndex) -> CFGIndex {
         //! Constructs graph for `exprs` evaluated in order
@@ -535,7 +535,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         opt_expr.iter().fold(pred, |p, e| self.expr(&**e, p))
     }
 
-    fn straightline<'b, I: Iterator<&'b ast::Expr>>(&mut self,
+    fn straightline<'b, I: Iterator<Item=&'b ast::Expr>>(&mut self,
                     expr: &ast::Expr,
                     pred: CFGIndex,
                     subexprs: I) -> CFGIndex {
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index d16224ec5b8ac..4151f5fa627ee 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -92,7 +92,7 @@ impl<'a> fmt::Show for Matrix<'a> {
 }
 
 impl<'a> FromIterator<Vec<&'a Pat>> for Matrix<'a> {
-    fn from_iter<T: Iterator<Vec<&'a Pat>>>(iterator: T) -> Matrix<'a> {
+    fn from_iter<T: Iterator<Item=Vec<&'a Pat>>>(iterator: T) -> Matrix<'a> {
         Matrix(iterator.collect())
     }
 }
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index 9fc5cb0335313..96b2a62326b17 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -81,7 +81,7 @@ pub fn join(a: constness, b: constness) -> constness {
     }
 }
 
-pub fn join_all<It: Iterator<constness>>(cs: It) -> constness {
+pub fn join_all<It: Iterator<Item=constness>>(cs: It) -> constness {
     cs.fold(integral_const, |a, b| join(a, b))
 }
 
diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs
index da00d737b473e..e8efdda3888a7 100644
--- a/src/librustc/middle/graph.rs
+++ b/src/librustc/middle/graph.rs
@@ -305,7 +305,9 @@ pub struct DepthFirstTraversal<'g, N:'g, E:'g> {
     visited: BitvSet
 }
 
-impl<'g, N, E> Iterator<&'g N> for DepthFirstTraversal<'g, N, E> {
+impl<'g, N, E> Iterator for DepthFirstTraversal<'g, N, E> {
+    type Item = &'g N;
+
     fn next(&mut self) -> Option<&'g N> {
         while let Some(idx) = self.stack.pop() {
             if !self.visited.insert(idx.node_id()) {
diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
index 97e74b9f6bbb9..e7971a82119ec 100644
--- a/src/librustc/middle/subst.rs
+++ b/src/librustc/middle/subst.rs
@@ -494,7 +494,9 @@ impl<'a,T> EnumeratedItems<'a,T> {
     }
 }
 
-impl<'a,T> Iterator<(ParamSpace, uint, &'a T)> for EnumeratedItems<'a,T> {
+impl<'a,T> Iterator for EnumeratedItems<'a,T> {
+    type Item = (ParamSpace, uint, &'a T);
+
     fn next(&mut self) -> Option<(ParamSpace, uint, &'a T)> {
         let spaces = ParamSpace::all();
         if self.space_index < spaces.len() {
diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs
index d09f2a250b033..bd901ff431a84 100644
--- a/src/librustc/middle/traits/select.rs
+++ b/src/librustc/middle/traits/select.rs
@@ -297,7 +297,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                                 stack: Option<&TraitObligationStack<'o, 'tcx>>,
                                                 mut predicates: I)
                                                 -> EvaluationResult<'tcx>
-        where I : Iterator<&'a PredicateObligation<'tcx>>, 'tcx:'a
+        where I : Iterator<Item=&'a PredicateObligation<'tcx>>, 'tcx:'a
     {
         let mut result = EvaluatedToOk;
         for obligation in predicates {
@@ -2315,9 +2315,9 @@ impl<'o, 'tcx> TraitObligationStack<'o, 'tcx> {
     }
 }
 
-impl<'o, 'tcx> Iterator<&'o TraitObligationStack<'o,'tcx>>
-           for Option<&'o TraitObligationStack<'o, 'tcx>>
-{
+impl<'o, 'tcx> Iterator for Option<&'o TraitObligationStack<'o, 'tcx>> {
+    type Item = &'o TraitObligationStack<'o,'tcx>;
+
     fn next(&mut self) -> Option<&'o TraitObligationStack<'o, 'tcx>> {
         match *self {
             Some(o) => {
diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs
index 41a59d6a5d846..e4578f7476329 100644
--- a/src/librustc/middle/traits/util.rs
+++ b/src/librustc/middle/traits/util.rs
@@ -133,7 +133,9 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> {
     }
 }
 
-impl<'cx, 'tcx> Iterator<ty::Predicate<'tcx>> for Elaborator<'cx, 'tcx> {
+impl<'cx, 'tcx> Iterator for Elaborator<'cx, 'tcx> {
+    type Item = ty::Predicate<'tcx>;
+
     fn next(&mut self) -> Option<ty::Predicate<'tcx>> {
         loop {
             // Extract next item from top-most stack frame, if any.
@@ -197,7 +199,9 @@ pub fn transitive_bounds<'cx, 'tcx>(tcx: &'cx ty::ctxt<'tcx>,
     elaborate_trait_refs(tcx, bounds).filter_to_traits()
 }
 
-impl<'cx, 'tcx> Iterator<ty::PolyTraitRef<'tcx>> for Supertraits<'cx, 'tcx> {
+impl<'cx, 'tcx> Iterator for Supertraits<'cx, 'tcx> {
+    type Item = ty::PolyTraitRef<'tcx>;
+
     fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
         loop {
             match self.elaborator.next() {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 999bc23c27049..f786ef8afee99 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -3716,10 +3716,10 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
                                    -> Representability {
 
     // Iterate until something non-representable is found
-    fn find_nonrepresentable<'tcx, It: Iterator<Ty<'tcx>>>(cx: &ctxt<'tcx>, sp: Span,
-                                                           seen: &mut Vec<Ty<'tcx>>,
-                                                           iter: It)
-                                                           -> Representability {
+    fn find_nonrepresentable<'tcx, It: Iterator<Item=Ty<'tcx>>>(cx: &ctxt<'tcx>, sp: Span,
+                                                                seen: &mut Vec<Ty<'tcx>>,
+                                                                iter: It)
+                                                                -> Representability {
         iter.fold(Representable,
                   |r, ty| cmp::max(r, is_type_structurally_recursive(cx, sp, seen, ty)))
     }
diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs
index 406ebf4bc38a4..12df36c10fc09 100644
--- a/src/librustc/middle/ty_walk.rs
+++ b/src/librustc/middle/ty_walk.rs
@@ -94,7 +94,9 @@ impl<'tcx> TypeWalker<'tcx> {
     }
 }
 
-impl<'tcx> Iterator<Ty<'tcx>> for TypeWalker<'tcx> {
+impl<'tcx> Iterator for TypeWalker<'tcx> {
+    type Item = Ty<'tcx>;
+
     fn next(&mut self) -> Option<Ty<'tcx>> {
         debug!("next(): stack={}", self.stack);
         match self.stack.pop() {
diff --git a/src/librustc/session/search_paths.rs b/src/librustc/session/search_paths.rs
index 56b4cae2e43cf..14ea2d3d33a26 100644
--- a/src/librustc/session/search_paths.rs
+++ b/src/librustc/session/search_paths.rs
@@ -53,7 +53,9 @@ impl SearchPaths {
     }
 }
 
-impl<'a> Iterator<&'a Path> for Iter<'a> {
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a Path;
+
     fn next(&mut self) -> Option<&'a Path> {
         loop {
             match self.iter.next() {
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index be55da8c59da2..9a993de098ea4 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -26,6 +26,7 @@
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(unboxed_closures)]
+#![feature(associated_types)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index a046d9d5d39c5..561099550cee3 100644
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -345,7 +345,9 @@ enum NodesMatchingUII<'a, 'ast: 'a> {
     NodesMatchingSuffix(ast_map::NodesMatchingSuffix<'a, 'ast>),
 }
 
-impl<'a, 'ast> Iterator<ast::NodeId> for NodesMatchingUII<'a, 'ast> {
+impl<'a, 'ast> Iterator for NodesMatchingUII<'a, 'ast> {
+    type Item = ast::NodeId;
+
     fn next(&mut self) -> Option<ast::NodeId> {
         match self {
             &NodesMatchingDirect(ref mut iter) => iter.next(),
diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs
index 93ff9f53ec12d..c3c97616ea838 100644
--- a/src/librustc_trans/back/link.rs
+++ b/src/librustc_trans/back/link.rs
@@ -266,7 +266,7 @@ pub fn sanitize(s: &str) -> String {
     return result;
 }
 
-pub fn mangle<PI: Iterator<PathElem>>(mut path: PI,
+pub fn mangle<PI: Iterator<Item=PathElem>>(mut path: PI,
                                       hash: Option<&str>) -> String {
     // Follow C++ namespace-mangling style, see
     // http://en.wikipedia.org/wiki/Name_mangling for more info.
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index 5ffe9b2d6471a..9dbff66aba286 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -28,6 +28,7 @@
 #![feature(rustc_diagnostic_macros)]
 #![feature(unboxed_closures)]
 #![feature(old_orphan_check)]
+#![feature(associated_types)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
index bf53885e9e50d..d1cb22dce38f7 100644
--- a/src/librustc_trans/trans/base.rs
+++ b/src/librustc_trans/trans/base.rs
@@ -3070,7 +3070,9 @@ fn internalize_symbols(cx: &SharedCrateContext, reachable: &HashSet<String>) {
         step: unsafe extern "C" fn(ValueRef) -> ValueRef,
     }
 
-    impl Iterator<ValueRef> for ValueIter {
+    impl Iterator for ValueIter {
+        type Item = ValueRef;
+
         fn next(&mut self) -> Option<ValueRef> {
             let old = self.cur;
             if !old.is_null() {
diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs
index 9ceb0c6399093..67aecde661891 100644
--- a/src/librustc_trans/trans/context.rs
+++ b/src/librustc_trans/trans/context.rs
@@ -168,7 +168,9 @@ pub struct CrateContextIterator<'a, 'tcx: 'a> {
     index: uint,
 }
 
-impl<'a, 'tcx> Iterator<CrateContext<'a, 'tcx>> for CrateContextIterator<'a,'tcx> {
+impl<'a, 'tcx> Iterator for CrateContextIterator<'a,'tcx> {
+    type Item = CrateContext<'a, 'tcx>;
+
     fn next(&mut self) -> Option<CrateContext<'a, 'tcx>> {
         if self.index >= self.shared.local_ccxs.len() {
             return None;
@@ -193,7 +195,9 @@ pub struct CrateContextMaybeIterator<'a, 'tcx: 'a> {
     origin: uint,
 }
 
-impl<'a, 'tcx> Iterator<(CrateContext<'a, 'tcx>, bool)> for CrateContextMaybeIterator<'a, 'tcx> {
+impl<'a, 'tcx> Iterator for CrateContextMaybeIterator<'a, 'tcx> {
+    type Item = (CrateContext<'a, 'tcx>, bool);
+
     fn next(&mut self) -> Option<(CrateContext<'a, 'tcx>, bool)> {
         if self.index >= self.shared.local_ccxs.len() {
             return None;
diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs
index 99624f1b1e7d8..f0588b3082ab6 100644
--- a/src/librustc_trans/trans/meth.rs
+++ b/src/librustc_trans/trans/meth.rs
@@ -727,7 +727,7 @@ pub fn get_vtable<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 }
 
 /// Helper function to declare and initialize the vtable.
-pub fn make_vtable<I: Iterator<ValueRef>>(ccx: &CrateContext,
+pub fn make_vtable<I: Iterator<Item=ValueRef>>(ccx: &CrateContext,
                                           drop_glue: ValueRef,
                                           size: ValueRef,
                                           align: ValueRef,
diff --git a/src/librustc_trans/trans/value.rs b/src/librustc_trans/trans/value.rs
index 9e959ce4221e7..028e2154303e2 100644
--- a/src/librustc_trans/trans/value.rs
+++ b/src/librustc_trans/trans/value.rs
@@ -155,7 +155,9 @@ pub struct Users {
     next: Option<Use>
 }
 
-impl Iterator<Value> for Users {
+impl Iterator for Users {
+    type Item = Value;
+
     fn next(&mut self) -> Option<Value> {
         let current = self.next;
 
diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs
index d01b79068aa2c..52501b08fd1f8 100644
--- a/src/librustc_typeck/check/regionck.rs
+++ b/src/librustc_typeck/check/regionck.rs
@@ -1052,11 +1052,11 @@ fn constrain_callee(rcx: &mut Rcx,
     }
 }
 
-fn constrain_call<'a, I: Iterator<&'a ast::Expr>>(rcx: &mut Rcx,
-                                                  call_expr: &ast::Expr,
-                                                  receiver: Option<&ast::Expr>,
-                                                  mut arg_exprs: I,
-                                                  implicitly_ref_args: bool) {
+fn constrain_call<'a, I: Iterator<Item=&'a ast::Expr>>(rcx: &mut Rcx,
+                                                       call_expr: &ast::Expr,
+                                                       receiver: Option<&ast::Expr>,
+                                                       mut arg_exprs: I,
+                                                       implicitly_ref_args: bool) {
     //! Invoked on every call site (i.e., normal calls, method calls,
     //! and overloaded operators). Constrains the regions which appear
     //! in the type of the function. Also constrains the regions that
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index fe61b3de2cf6f..8c2cb557c1c9d 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -428,7 +428,7 @@ fn convert_methods<'a,'tcx,'i,I>(ccx: &CrateCtxt<'a, 'tcx>,
                                  untransformed_rcvr_ty: Ty<'tcx>,
                                  rcvr_ty_generics: &ty::Generics<'tcx>,
                                  rcvr_visibility: ast::Visibility)
-                                 where I: Iterator<&'i ast::Method> {
+                                 where I: Iterator<Item=&'i ast::Method> {
     debug!("convert_methods(untransformed_rcvr_ty={}, rcvr_ty_generics={})",
            untransformed_rcvr_ty.repr(ccx.tcx),
            rcvr_ty_generics.repr(ccx.tcx));
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 353db82eb027d..cc5b1f635e370 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -104,9 +104,6 @@ use syntax::print::pprust::*;
 use syntax::{ast, ast_map, abi};
 use syntax::ast_util::local_def;
 
-#[cfg(stage0)]
-mod diagnostics;
-
 mod check;
 mod rscope;
 mod astconv;
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index a87044bb3b3ba..83badb0c57c82 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -1324,7 +1324,9 @@ pub struct Parser<T> {
     state: ParserState,
 }
 
-impl<T: Iterator<char>> Iterator<JsonEvent> for Parser<T> {
+impl<T: Iterator<Item=char>> Iterator for Parser<T> {
+    type Item = JsonEvent;
+
     fn next(&mut self) -> Option<JsonEvent> {
         if self.state == ParseFinished {
             return None;
@@ -1345,7 +1347,7 @@ impl<T: Iterator<char>> Iterator<JsonEvent> for Parser<T> {
     }
 }
 
-impl<T: Iterator<char>> Parser<T> {
+impl<T: Iterator<Item=char>> Parser<T> {
     /// Creates the JSON parser.
     pub fn new(rdr: T) -> Parser<T> {
         let mut p = Parser {
@@ -1867,7 +1869,7 @@ pub struct Builder<T> {
     token: Option<JsonEvent>,
 }
 
-impl<T: Iterator<char>> Builder<T> {
+impl<T: Iterator<Item=char>> Builder<T> {
     /// Create a JSON Builder.
     pub fn new(src: T) -> Builder<T> {
         Builder { parser: Parser::new(src), token: None, }
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 4a2bbbeec03a4..1ec6a2af309a7 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -25,6 +25,7 @@ Core encoding and decoding interfaces.
 #![allow(unknown_features)]
 #![feature(macro_rules, default_type_params, phase, slicing_syntax, globs)]
 #![feature(unboxed_closures)]
+#![feature(associated_types)]
 
 // test harness access
 #[cfg(test)]
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index b1433ad7fdc62..834a9f082d03a 100644
--- 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 d4fc4150fae91..6450b149d0242 100644
--- 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 @@ impl<'a, K, V> VacantEntry<'a, K, 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 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for Has
 
 #[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 6132d288da279..ea8298c48c83f 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -603,7 +603,7 @@ impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
 
 #[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 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T,
 
 #[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 @@ impl<'a, T, S, H> Iterator<&'a T> for Intersection<'a, T, H>
 }
 
 #[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 @@ impl<'a, T, S, H> Iterator<&'a T> for Difference<'a, T, H>
 }
 
 #[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 a687ba3da8d7f..2b999d83a98c2 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -730,7 +730,9 @@ impl<'a, K, V> Clone for 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 @@ impl<'a, K, V> Iterator<(&'a K, &'a V)> for Iter<'a, K, V> {
     }
 }
 
-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 @@ impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for IterMut<'a, K, V> {
     }
 }
 
-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 @@ impl<K, V> Iterator<(SafeHash, K, V)> for IntoIter<K, V> {
     }
 }
 
-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 94dba1f7cc70a..8c097a65db7bd 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -52,7 +52,9 @@ impl<'r, R: Reader> 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 7fa5b3cfac7e2..1ff54fcb48432 100644
--- 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 0a7815aeb5367..917ffa4ff76da 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1036,7 +1036,6 @@ pub trait Writer {
             error: IoResult<()>,
         }
 
-        #[cfg(not(stage0))]
         impl<'a, Sized? T: Writer> fmt::Writer for Adaptor<'a, T> {
             fn write_str(&mut self, s: &str) -> fmt::Result {
                 match self.inner.write(s.as_bytes()) {
@@ -1049,19 +1048,6 @@ pub trait Writer {
             }
         }
 
-        #[cfg(stage0)]
-        impl<'a, T: Writer> fmt::Writer for Adaptor<'a, T> {
-            fn write_str(&mut self, s: &str) -> fmt::Result {
-                match self.inner.write(s.as_bytes()) {
-                    Ok(()) => Ok(()),
-                    Err(e) => {
-                        self.error = Err(e);
-                        Err(fmt::Error)
-                    }
-                }
-            }
-        }
-
         let mut output = Adaptor { inner: self, error: Ok(()) };
         match fmt::write(&mut output, fmt) {
             Ok(()) => Ok(()),
@@ -1371,7 +1357,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 +1386,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)),
@@ -1648,15 +1638,9 @@ pub struct IncomingConnections<'a, Sized? A:'a> {
     inc: &'a mut A,
 }
 
-#[cfg(stage0)]
-impl<'a, T, A: Acceptor<T>> Iterator<IoResult<T>> for IncomingConnections<'a, A> {
-    fn next(&mut self) -> Option<IoResult<T>> {
-        Some(self.inc.accept())
-    }
-}
+impl<'a, T, Sized? A: Acceptor<T>> Iterator for IncomingConnections<'a, A> {
+    type Item = IoResult<T>;
 
-#[cfg(not(stage0))]
-impl<'a, T, Sized? A: Acceptor<T>> Iterator<IoResult<T>> for IncomingConnections<'a, A> {
     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 38ab71c172c59..51d1bacf63b9f 100644
--- 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 @@ impl<R: Reader, I: Iterator<R>> 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 @@ impl<T: Iterator<u8>> 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/path/posix.rs b/src/libstd/path/posix.rs
index 6075010f3b5ff..39b96ef6aeea0 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -15,7 +15,7 @@ use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use hash;
 use io::Writer;
-use iter::{DoubleEndedIteratorExt, AdditiveIterator, Extend};
+use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
 use option::Option;
 use option::Option::{None, Some};
@@ -449,7 +449,7 @@ mod tests {
     use super::*;
 
     use clone::Clone;
-    use iter::{IteratorExt, DoubleEndedIteratorExt};
+    use iter::IteratorExt;
     use option::Option::{mod, Some, None};
     use path::GenericPath;
     use slice::{AsSlice, SliceExt};
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 55086ad3a23f9..f6fb149e82cf6 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -20,7 +20,7 @@ use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use hash;
 use io::Writer;
-use iter::{AdditiveIterator, DoubleEndedIteratorExt, Extend};
+use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option;
@@ -1124,7 +1124,7 @@ mod tests {
     use super::*;
 
     use clone::Clone;
-    use iter::{IteratorExt, DoubleEndedIteratorExt};
+    use iter::IteratorExt;
     use option::Option::{mod, Some, None};
     use path::GenericPath;
     use slice::{AsSlice, SliceExt};
diff --git a/src/libstd/prelude/mod.rs b/src/libstd/prelude/mod.rs
index da945b4c9fa08..1fbd17ede08f2 100644
--- a/src/libstd/prelude/mod.rs
+++ b/src/libstd/prelude/mod.rs
@@ -35,8 +35,5 @@
 //! pervasive that it would be obnoxious to import for every use, particularly
 //! those that define methods on primitive types.
 
-#[cfg(stage0)]
-pub use self::v1::*;
-
 #[stable]
 pub mod v1;
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index cb5dfafb4a123..2d2f3f895d0c1 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -27,11 +27,9 @@
 #[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::DoubleEndedIteratorExt;
 #[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 iter::IteratorPairExt;
 #[stable] #[doc(no_inline)] pub use option::Option::{mod, Some, None};
 #[stable] #[doc(no_inline)] pub use ptr::{PtrExt, MutPtrExt};
 #[stable] #[doc(no_inline)] pub use result::Result::{mod, Ok, Err};
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 86b8bfc73709d..208e4f9e566f4 100644
--- 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 413675f26d59c..e9dc3d986ba11 100644
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -936,7 +936,9 @@ impl<T: Send> select::Packet for Receiver<T> {
 }
 
 #[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 43554d7c335a4..3d9dca7e21cb3 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -319,7 +319,9 @@ impl<'rx, T: Send> Drop for Handle<'rx, T> {
     }
 }
 
-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
diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs
index b5395d09ca7d4..b1799fc2718ff 100644
--- a/src/libsyntax/ast_map/mod.rs
+++ b/src/libsyntax/ast_map/mod.rs
@@ -61,7 +61,9 @@ struct LinkedPathNode<'a> {
 
 type LinkedPath<'a> = Option<&'a LinkedPathNode<'a>>;
 
-impl<'a> Iterator<PathElem> for LinkedPath<'a> {
+impl<'a> Iterator for LinkedPath<'a> {
+    type Item = PathElem;
+
     fn next(&mut self) -> Option<PathElem> {
         match *self {
             Some(node) => {
@@ -77,7 +79,9 @@ impl<'a> Iterator<PathElem> for LinkedPath<'a> {
 #[deriving(Clone)]
 pub struct Values<'a, T:'a>(pub slice::Iter<'a, T>);
 
-impl<'a, T: Copy> Iterator<T> for Values<'a, T> {
+impl<'a, T: Copy> Iterator for Values<'a, T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         let &Values(ref mut items) = self;
         items.next().map(|&x| x)
@@ -87,7 +91,7 @@ impl<'a, T: Copy> Iterator<T> for Values<'a, T> {
 /// The type of the iterator used by with_path.
 pub type PathElems<'a, 'b> = iter::Chain<Values<'a, PathElem>, LinkedPath<'b>>;
 
-pub fn path_to_string<PI: Iterator<PathElem>>(path: PI) -> String {
+pub fn path_to_string<PI: Iterator<Item=PathElem>>(path: PI) -> String {
     let itr = token::get_ident_interner();
 
     path.fold(String::new(), |mut s, e| {
@@ -629,7 +633,9 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> {
     }
 }
 
-impl<'a, 'ast> Iterator<NodeId> for NodesMatchingSuffix<'a, 'ast> {
+impl<'a, 'ast> Iterator for NodesMatchingSuffix<'a, 'ast> {
+    type Item = NodeId;
+
     fn next(&mut self) -> Option<NodeId> {
         loop {
             let idx = self.idx;
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index df820b40cb6de..92818f0634160 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -359,7 +359,7 @@ pub enum StabilityLevel {
 
 pub fn find_stability_generic<'a,
                               AM: AttrMetaMethods,
-                              I: Iterator<&'a AM>>
+                              I: Iterator<Item=&'a AM>>
                              (mut attrs: I)
                              -> Option<(Stability, &'a AM)> {
     for attr in attrs {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index efb4867a016be..e56194c95cd5b 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -220,7 +220,7 @@ pub struct MacItems {
 }
 
 impl MacItems {
-    pub fn new<I: Iterator<P<ast::Item>>>(it: I) -> Box<MacResult+'static> {
+    pub fn new<I: Iterator<Item=P<ast::Item>>>(it: I) -> Box<MacResult+'static> {
         box MacItems { items: it.collect() } as Box<MacResult+'static>
     }
 }
diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
index bc2e09231159a..38c26e8967140 100644
--- a/src/libsyntax/owned_slice.rs
+++ b/src/libsyntax/owned_slice.rs
@@ -77,7 +77,7 @@ impl<T: Clone> Clone for OwnedSlice<T> {
 }
 
 impl<T> FromIterator<T> for OwnedSlice<T> {
-    fn from_iter<I: Iterator<T>>(iter: I) -> OwnedSlice<T> {
+    fn from_iter<I: Iterator<Item=T>>(iter: I) -> OwnedSlice<T> {
         OwnedSlice::from_vec(iter.collect())
     }
 }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 88c485a07acdf..8598571e5c37a 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -598,7 +598,7 @@ pub fn binary_lit(lit: &str) -> Rc<Vec<u8>> {
     let error = |&: i| format!("lexer should have rejected {} at {}", lit, i);
 
     /// Eat everything up to a non-whitespace
-    fn eat<'a, I: Iterator<(uint, u8)>>(it: &mut iter::Peekable<(uint, u8), I>) {
+    fn eat<'a, I: Iterator<Item=(uint, u8)>>(it: &mut iter::Peekable<(uint, u8), I>) {
         loop {
             match it.peek().map(|x| x.1) {
                 Some(b' ') | Some(b'\n') | Some(b'\r') | Some(b'\t') => {
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 953a7ae960e8c..b68c9926391d7 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -30,7 +30,7 @@ enum SmallVectorRepr<T> {
 }
 
 impl<T> FromIterator<T> for SmallVector<T> {
-    fn from_iter<I: Iterator<T>>(iter: I) -> SmallVector<T> {
+    fn from_iter<I: Iterator<Item=T>>(iter: I) -> SmallVector<T> {
         let mut v = SmallVector::zero();
         v.extend(iter);
         v
@@ -38,7 +38,7 @@ impl<T> FromIterator<T> for SmallVector<T> {
 }
 
 impl<T> Extend<T> for SmallVector<T> {
-    fn extend<I: Iterator<T>>(&mut self, mut iter: I) {
+    fn extend<I: Iterator<Item=T>>(&mut self, mut iter: I) {
         for val in iter {
             self.push(val);
         }
@@ -147,7 +147,9 @@ enum IntoIterRepr<T> {
     ManyIterator(vec::IntoIter<T>),
 }
 
-impl<T> Iterator<T> for IntoIter<T> {
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         match self.repr {
             ZeroIterator => None,
diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs
index ed6a00a8e9115..e8ab1b548433b 100644
--- a/src/libtest/stats.rs
+++ b/src/libtest/stats.rs
@@ -438,7 +438,7 @@ pub fn write_boxplot<W: Writer, T: Float + Show + FromPrimitive>(
 
 /// Returns a HashMap with the number of occurrences of every element in the
 /// sequence that the iterator exposes.
-pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hash_map::HashMap<U, uint> {
+pub fn freq_count<T: Iterator<Item=U>, U: Eq+Hash>(mut iter: T) -> hash_map::HashMap<U, uint> {
     let mut map: hash_map::HashMap<U,uint> = hash_map::HashMap::new();
     for elem in iter {
         match map.entry(elem) {
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index d33362ec23295..eabe044ce3b71 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -29,6 +29,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![no_std]
 #![feature(globs, macro_rules, slicing_syntax, unboxed_closures)]
+#![feature(associated_types)]
 
 extern crate core;
 
diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs
index e17bf025cba7c..8ec90acb711f0 100644
--- a/src/libunicode/u_str.rs
+++ b/src/libunicode/u_str.rs
@@ -105,7 +105,9 @@ pub struct GraphemeIndices<'a> {
     iter: Graphemes<'a>,
 }
 
-impl<'a> Iterator<(uint, &'a str)> for GraphemeIndices<'a> {
+impl<'a> Iterator for GraphemeIndices<'a> {
+    type Item = (uint, &'a str);
+
     #[inline]
     fn next(&mut self) -> Option<(uint, &'a str)> {
         self.iter.next().map(|s| (s.as_ptr() as uint - self.start_offset, s))
@@ -117,7 +119,7 @@ impl<'a> Iterator<(uint, &'a str)> for GraphemeIndices<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator<(uint, &'a str)> for GraphemeIndices<'a> {
+impl<'a> DoubleEndedIterator for GraphemeIndices<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<(uint, &'a str)> {
         self.iter.next_back().map(|s| (s.as_ptr() as uint - self.start_offset, s))
@@ -145,7 +147,9 @@ enum GraphemeState {
     Regional,
 }
 
-impl<'a> Iterator<&'a str> for Graphemes<'a> {
+impl<'a> Iterator for Graphemes<'a> {
+    type Item = &'a str;
+
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         let slen = self.string.len();
@@ -251,7 +255,7 @@ impl<'a> Iterator<&'a str> for Graphemes<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator<&'a str> for Graphemes<'a> {
+impl<'a> DoubleEndedIterator for Graphemes<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> {
         use tables::grapheme as gr;
@@ -428,7 +432,9 @@ impl Utf16Item {
     }
 }
 
-impl<'a> Iterator<Utf16Item> for Utf16Items<'a> {
+impl<'a> Iterator for Utf16Items<'a> {
+    type Item = Utf16Item;
+
     fn next(&mut self) -> Option<Utf16Item> {
         let u = match self.iter.next() {
             Some(u) => *u,
@@ -505,12 +511,14 @@ pub struct Utf16Encoder<I> {
 
 impl<I> Utf16Encoder<I> {
     /// Create an UTF-16 encoder from any `char` iterator.
-    pub fn new(chars: I) -> Utf16Encoder<I> where I: Iterator<char> {
+    pub fn new(chars: I) -> Utf16Encoder<I> where I: Iterator<Item=char> {
         Utf16Encoder { chars: chars, extra: 0 }
     }
 }
 
-impl<I> Iterator<u16> for Utf16Encoder<I> where I: Iterator<char> {
+impl<I> Iterator for Utf16Encoder<I> where I: Iterator<Item=char> {
+    type Item = u16;
+
     #[inline]
     fn next(&mut self) -> Option<u16> {
         if self.extra != 0 {
@@ -537,9 +545,11 @@ impl<I> Iterator<u16> for Utf16Encoder<I> where I: Iterator<char> {
     }
 }
 
-impl<'a> Iterator<&'a str> for Words<'a> {
+impl<'a> Iterator for Words<'a> {
+    type Item = &'a str;
+
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
 }
-impl<'a> DoubleEndedIterator<&'a str> for Words<'a> {
+impl<'a> DoubleEndedIterator for Words<'a> {
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
 }
diff --git a/src/snapshots.txt b/src/snapshots.txt
index 34beb53bd07cc..c72fd7978f885 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,12 @@
+S 2015-01-02 c894171
+  freebsd-x86_64 ea8bcf75eada3539f5cbab51708eecf40d436b77
+  linux-i386 646ae265721e3cbe19404aae4fea4ffa1f1d90cf
+  linux-x86_64 85183ce0724af3dfb7616b9e81a4e5510415f351
+  macos-i386 b3eced7fc5e78f767edb4595dfcde02dad206f3f
+  macos-x86_64 36418bce8c18f1b49ec6b5aec2bf35ff1cd833a3
+  winnt-i386 6c7ddf23b389be723d34ab91a9baa4a06c5f9571
+  winnt-x86_64 d086d4019d603db09166d0609a21da8ee8fe306a
+
 S 2015-01-01 7d4f487
   freebsd-x86_64 5dc87adb17bc33abc08f1bf4c092e0b5b92a6ca4
   linux-i386 63bf82a5b540d8acbbf1e445ce48be0fa0f003fc
diff --git a/src/test/auxiliary/issue-16643.rs b/src/test/auxiliary/issue-16643.rs
index b30ccb4dded0d..41572998b58a4 100644
--- a/src/test/auxiliary/issue-16643.rs
+++ b/src/test/auxiliary/issue-16643.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "lib"]
+#![feature(associated_types)]
 
 pub struct TreeBuilder<H>;
 
@@ -20,7 +21,9 @@ impl<H> TreeBuilder<H> {
     }
 }
 
-impl<H> Iterator<H> for TreeBuilder<H> {
+impl<H> Iterator for TreeBuilder<H> {
+    type Item = H;
+
     fn next(&mut self) -> Option<H> {
         None
     }
diff --git a/src/test/auxiliary/nested_item.rs b/src/test/auxiliary/nested_item.rs
index d97a2e3cda129..1a2f429c9ebc1 100644
--- a/src/test/auxiliary/nested_item.rs
+++ b/src/test/auxiliary/nested_item.rs
@@ -26,7 +26,7 @@ impl<T> Foo {
 
 // issue 8134
 pub struct Parser<T>;
-impl<T: std::iter::Iterator<char>> Parser<T> {
+impl<T: std::iter::Iterator<Item=char>> Parser<T> {
     fn in_doctype(&mut self) {
         static DOCTYPEPattern: [char; 6] = ['O', 'C', 'T', 'Y', 'P', 'E'];
     }
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 7009dd4c1a76f..ccc50b867dcd6 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -75,7 +75,9 @@ impl<'a> AAGen<'a> {
         AAGen { rng: rng, data: data }
     }
 }
-impl<'a> Iterator<u8> for AAGen<'a> {
+impl<'a> Iterator for AAGen<'a> {
+    type Item = u8;
+
     fn next(&mut self) -> Option<u8> {
         let r = self.rng.gen();
         self.data.iter()
@@ -85,7 +87,7 @@ impl<'a> Iterator<u8> for AAGen<'a> {
     }
 }
 
-fn make_fasta<W: Writer, I: Iterator<u8>>(
+fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
     wr: &mut W, header: &str, mut it: I, mut n: uint)
     -> std::io::IoResult<()>
 {
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 26ef696b616ce..ff681ca7f1470 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -194,7 +194,9 @@ impl Table {
     }
 }
 
-impl<'a> Iterator<&'a Entry> for Items<'a> {
+impl<'a> Iterator for Items<'a> {
+    type Item = &'a Entry;
+
     fn next(&mut self) -> Option<&'a Entry> {
         let ret = match self.cur {
             None => {
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index 0c3152d4780f2..004d90fd6e550 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -57,7 +57,9 @@ struct Iterate<'a, T> {
     f: |&T|: 'a -> T,
     next: T
 }
-impl<'a, T> Iterator<T> for Iterate<'a, T> {
+impl<'a, T> Iterator for Iterate<'a, T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         let mut res = (self.f)(&self.next);
         std::mem::swap(&mut res, &mut self.next);
@@ -78,7 +80,9 @@ impl<'a, T> List<'a, T> {
         ListIterator{cur: self}
     }
 }
-impl<'a, T> Iterator<&'a T> for ListIterator<'a, T> {
+impl<'a, T> Iterator for ListIterator<'a, T> {
+    type Item = &'a T;
+
     fn next(&mut self) -> Option<&'a T> {
         match *self.cur {
             List::Nil => None,
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index a138684330365..c85aae4dd2fac 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -150,7 +150,9 @@ struct MutDnaSeqs<'a> { s: &'a mut [u8] }
 fn mut_dna_seqs<'a>(s: &'a mut [u8]) -> MutDnaSeqs<'a> {
     MutDnaSeqs { s: s }
 }
-impl<'a> Iterator<&'a mut [u8]> for MutDnaSeqs<'a> {
+impl<'a> Iterator for MutDnaSeqs<'a> {
+    type Item = &'a mut [u8];
+
     fn next(&mut self) -> Option<&'a mut [u8]> {
         let tmp = std::mem::replace(&mut self.s, &mut []);
         let tmp = match memchr(tmp, b'\n') {
@@ -229,7 +231,7 @@ unsafe impl<T: 'static> Send for Racy<T> {}
 /// The closure `f` is run in parallel with an element of `iter`.
 fn parallel<'a, I, T, F>(mut iter: I, f: F)
         where T: 'a+Send + Sync,
-              I: Iterator<&'a mut [T]>,
+              I: Iterator<Item=&'a mut [T]>,
               F: Fn(&mut [T]) + Sync {
     use std::mem;
     use std::raw::Repr;
diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 5203c91237be8..8dda54efc06af 100644
--- a/src/test/compile-fail/issue-13058.rs
+++ b/src/test/compile-fail/issue-13058.rs
@@ -10,7 +10,7 @@
 
 use std::iter::{Range,range};
 
-trait Itble<'r, T, I: Iterator<T>> { fn iter(&'r self) -> I; }
+trait Itble<'r, T, I: Iterator<Item=T>> { fn iter(&'r self) -> I; }
 
 impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
     fn iter(&'r self) -> Range<uint> {
@@ -19,8 +19,8 @@ impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
     }
 }
 
-fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool
-//~^ HELP as shown: fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &'r T) -> bool
+fn check<'r, I: Iterator<Item=uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool
+//~^ HELP as shown: fn check<'r, I: Iterator<Item = uint>, T: Itble<'r, uint, I>>(cont: &'r T)
 {
     let cont_iter = cont.iter();
 //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements
diff --git a/src/test/compile-fail/issue-13853.rs b/src/test/compile-fail/issue-13853.rs
index 868836a4bbd0a..509ca9b80f81f 100644
--- a/src/test/compile-fail/issue-13853.rs
+++ b/src/test/compile-fail/issue-13853.rs
@@ -13,11 +13,11 @@ trait Node {
 }
 
 trait Graph<N: Node> {
-    fn nodes<'a, I: Iterator<&'a N>>(&'a self) -> I;
+    fn nodes<'a, I: Iterator<Item=&'a N>>(&'a self) -> I;
 }
 
 impl<N: Node> Graph<N> for Vec<N> {
-    fn nodes<'a, I: Iterator<&'a N>>(&self) -> I {
+    fn nodes<'a, I: Iterator<Item=&'a N>>(&self) -> I {
         self.iter() //~ ERROR mismatched types
     }
 }
diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
index 7c514b4e16f07..7d91b1998bf24 100644
--- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
+++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
@@ -12,7 +12,7 @@
 
 use std::iter::{Range,range};
 
-trait Itble<'r, T, I: Iterator<T>> { fn iter(&'r self) -> I; }
+trait Itble<'r, T, I: Iterator<Item=T>> { fn iter(&'r self) -> I; }
 
 impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
     fn iter(&'r self) -> Range<uint> {
@@ -21,8 +21,8 @@ impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
     }
 }
 
-fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &'r T) -> bool
+fn check<'r, I: Iterator<Item=uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<Item = uint>, T: Itble<'r, uint, I>>(cont: &'r T)
     let cont_iter = cont.iter(); //~ ERROR: cannot infer
     let result = cont_iter.fold(Some(0u16), |state, val| {
         state.map_or(None, |mask| {
diff --git a/src/test/compile-fail/static-reference-to-fn-2.rs b/src/test/compile-fail/static-reference-to-fn-2.rs
index d7255c3ba0694..2bdbdb4fde295 100644
--- a/src/test/compile-fail/static-reference-to-fn-2.rs
+++ b/src/test/compile-fail/static-reference-to-fn-2.rs
@@ -8,13 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(associated_types)]
+
 struct StateMachineIter<'a> {
     statefn: &'a StateMachineFunc<'a>
 }
 
 type StateMachineFunc<'a> = fn(&mut StateMachineIter<'a>) -> Option<&'static str>;
 
-impl<'a> Iterator<&'static str> for StateMachineIter<'a> {
+impl<'a> Iterator for StateMachineIter<'a> {
+    type Item = &'static str;
+
     fn next(&mut self) -> Option<&'static str> {
         return  (*self.statefn)(self);
     }
diff --git a/src/test/run-pass/issue-13167.rs b/src/test/run-pass/issue-13167.rs
index 1282077028ffb..ee556ce2c8459 100644
--- a/src/test/run-pass/issue-13167.rs
+++ b/src/test/run-pass/issue-13167.rs
@@ -8,13 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(associated_types)]
+
 use std::slice;
 
 pub struct PhfMapEntries<'a, T: 'a> {
     iter: slice::Iter<'a, (&'static str, T)>,
 }
 
-impl<'a, T> Iterator<(&'static str, &'a T)> for PhfMapEntries<'a, T> {
+impl<'a, T> Iterator for PhfMapEntries<'a, T> {
+    type Item = (&'static str, &'a T);
+
     fn next(&mut self) -> Option<(&'static str, &'a T)> {
         self.iter.by_ref().map(|&(key, ref value)| (key, value)).next()
     }
diff --git a/src/test/run-pass/issue-13204.rs b/src/test/run-pass/issue-13204.rs
index f9b542dea56f0..c29dc4319dc0c 100644
--- a/src/test/run-pass/issue-13204.rs
+++ b/src/test/run-pass/issue-13204.rs
@@ -12,7 +12,7 @@
 // lifetime parameters defined on the method bound correctly.
 
 pub trait Foo {
-    fn bar<'a, I: Iterator<&'a ()>>(&self, it: I) -> uint {
+    fn bar<'a, I: Iterator<Item=&'a ()>>(&self, it: I) -> uint {
         let mut xs = it.filter(|_| true);
         xs.count()
     }
diff --git a/src/test/run-pass/issue-14919.rs b/src/test/run-pass/issue-14919.rs
index db29eb314bd70..d66bbe9187a28 100644
--- a/src/test/run-pass/issue-14919.rs
+++ b/src/test/run-pass/issue-14919.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(associated_types)]
+
 trait Matcher {
     fn next_match(&mut self) -> Option<(uint, uint)>;
 }
@@ -40,7 +42,9 @@ struct MatchIndices<M> {
     matcher: M
 }
 
-impl<M: Matcher> Iterator<(uint, uint)> for MatchIndices<M> {
+impl<M: Matcher> Iterator for MatchIndices<M> {
+    type Item = (uint, uint);
+
     fn next(&mut self) -> Option<(uint, uint)> {
         self.matcher.next_match()
     }
diff --git a/src/test/run-pass/issue-16596.rs b/src/test/run-pass/issue-16596.rs
index df959fa0bda93..7bc6d989fa75c 100644
--- a/src/test/run-pass/issue-16596.rs
+++ b/src/test/run-pass/issue-16596.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(associated_types)]
+
 trait MatrixRow {}
 
 struct Mat;
@@ -18,7 +20,9 @@ struct Rows<M: MatrixRow> {
     mat: M,
 }
 
-impl<'a> Iterator<()> for Rows<&'a Mat> {
+impl<'a> Iterator for Rows<&'a Mat> {
+    type Item = ();
+
     fn next(&mut self) -> Option<()> {
         unimplemented!()
     }
diff --git a/src/test/run-pass/regions-no-bound-in-argument-cleanup.rs b/src/test/run-pass/regions-no-bound-in-argument-cleanup.rs
index 27d9895097863..d52c1c0b12c53 100644
--- a/src/test/run-pass/regions-no-bound-in-argument-cleanup.rs
+++ b/src/test/run-pass/regions-no-bound-in-argument-cleanup.rs
@@ -8,11 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unsafe_destructor)]
+#![feature(associated_types, unsafe_destructor)]
 
 pub struct Foo<T>;
 
-impl<T> Iterator<T> for Foo<T> {
+impl<T> Iterator for Foo<T> {
+    type Item = T;
+
     fn next(&mut self) -> Option<T> {
         None
     }
diff --git a/src/test/run-pass/where-clauses-lifetimes.rs b/src/test/run-pass/where-clauses-lifetimes.rs
index 4adaf7a11e30f..237c83c8aa23a 100644
--- a/src/test/run-pass/where-clauses-lifetimes.rs
+++ b/src/test/run-pass/where-clauses-lifetimes.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo<'a, I>(mut it: I) where I: Iterator<&'a int> {}
+fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a int> {}
 
 fn main() {
     foo([1i, 2].iter());