diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index f0151dda8d7..aa6028a19b3 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/iter.rs b/src/libcore/iter.rs
index d7a675b3104..c4b3531d539 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)),
@@ -689,11 +722,11 @@ pub trait IteratorExt<A>: Iterator<A> + Sized {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I> IteratorExt<A> for I where I: Iterator<A> {}
+impl<I> IteratorExt for I where I: Iterator {}
 
 /// 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 {
+pub trait IteratorPairExt<A, B>: Iterator<Item=(A, B)> + Sized {
     /// Converts an iterator of pairs into a pair of containers.
     ///
     /// Loops through the entire iterator, collecting the first component of
@@ -702,7 +735,9 @@ pub trait IteratorPairExt<A, B>: Iterator<(A, B)> + Sized {
         FromA: Default + Extend<A>, FromB: Default + Extend<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,21 +760,21 @@ pub trait IteratorPairExt<A, B>: Iterator<(A, B)> + Sized {
     }
 }
 
-impl<A, B, I> IteratorPairExt<A, B> for I where I: Iterator<(A, B)> {}
+impl<A, B, I> IteratorPairExt<A, B> for I where I: Iterator<Item=(A, B)> {}
 
 /// 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>;
+    fn next_back(&mut self) -> Option< <Self as Iterator>::Item>;
 }
 
 /// Extension methods for double-ended iterators.
 #[unstable = "new extension trait convention"]
-pub trait DoubleEndedIteratorExt<A>: DoubleEndedIterator<A> + Sized {
+pub trait DoubleEndedIteratorExt: DoubleEndedIterator + Sized {
     /// Change the direction of the iterator
     ///
     /// The flipped iterator swaps the ends on an iterator that can already
@@ -760,7 +795,7 @@ pub trait DoubleEndedIteratorExt<A>: DoubleEndedIterator<A> + Sized {
 }
 
 #[unstable = "trait is unstable"]
-impl<A, I> DoubleEndedIteratorExt<A> for I where I: DoubleEndedIterator<A> {}
+impl<I> DoubleEndedIteratorExt for I where I: DoubleEndedIterator {}
 
 /// A double-ended iterator yielding mutable references
 #[experimental = "not widely used"]
@@ -771,7 +806,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 +829,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 +846,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 +879,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 +904,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 +933,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 +973,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 +1017,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 +1098,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 +1110,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 +1119,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 +1216,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 +1231,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 +1247,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 +1283,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 +1294,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 +1322,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 +1335,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 +1352,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 +1393,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 +1407,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 +1418,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 +1432,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 +1474,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 +1499,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 +1523,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 +1531,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 +1542,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 +1553,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 +1569,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 +1581,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 +1600,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 +1608,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 +1620,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 +1643,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 +1661,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 +1669,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 +1681,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 +1706,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 +1726,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 +1754,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 +1768,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 +1787,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 +1818,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 +1842,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 +1851,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 +1864,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 +1888,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 +1897,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 +1910,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 +1943,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 +1993,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 +2013,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 +2048,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 +2068,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 +2079,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 +2093,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 +2116,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 +2130,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 +2145,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 +2180,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 +2207,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 +2242,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 +2261,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 +2287,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 +2295,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 +2306,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 +2319,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 +2335,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 +2347,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 +2430,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 +2464,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 +2513,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 +2563,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 +2594,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 +2629,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 +2664,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 +2708,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 +2802,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 +2812,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 +2887,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 +2902,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 +2921,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 +2942,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 +2957,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 +2970,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 +2986,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 +3002,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 +3018,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 b51d4d91c2f..c5441359ad0 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 b9749f57d58..92209b937d9 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/result.rs b/src/libcore/result.rs
index bd1c6dbcf1e..b0ee5672e06 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 07addf7a569..bc4e8d32887 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 f4fe86a0d7e..8df072c9d46 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -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() }
 }