std: Move the iterator param on FromIterator and Extendable to the method.

huonw · huonw · commit 53487a02467e · 2013-08-15T01:10:45.000+10:00
If they are on the trait then it is extremely annoying to use them as
generic parameters to a function, e.g. with the iterator param on the trait
itself, if one was to pass an Extendable&lt;int&gt; to a function that filled it
either from a Range or a Map&lt;VecIterator&gt;, one needs to write something
like:

    fn foo&lt;E: Extendable&lt;int, Range&lt;int&gt;&gt; +
              Extendable&lt;int, Map&lt;&amp;'self int, int, VecIterator&lt;int&gt;&gt;&gt;
          (e: &amp;mut E, ...) { ... }

since using a generic, i.e. `foo&lt;E: Extendable&lt;int, I&gt;, I: Iterator&lt;int&gt;&gt;`
means that `foo` takes 2 type parameters, and the caller has to specify them
(which doesn't work anyway, as they'll mismatch with the iterators used in
`foo` itself).

This patch changes it to:

    fn foo&lt;E: Extendable&lt;int&gt;&gt;(e: &amp;mut E, ...) { ... }
diff --git a/doc/po/tutorial-container.md.pot b/doc/po/tutorial-container.md.pot
@@ -483,8 +483,8 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~\n"
-"impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {\n"
-"    pub fn from_iterator(iterator: &mut T) -> ~[A] {\n"
+"impl<A> FromIterator<A> for ~[A] {\n"
+"    pub fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {\n"
 "        let (lower, _) = iterator.size_hint();\n"
 "        let mut xs = with_capacity(lower);\n"
 "        for x in iterator {\n"
diff --git a/doc/tutorial-container.md b/doc/tutorial-container.md
@@ -224,8 +224,8 @@ implementing the `FromIterator` trait. For example, the implementation for
 vectors is as follows:
 
 ~~~
-impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
-    pub fn from_iterator(iterator: &mut T) -> ~[A] {
+impl<A> FromIterator<A> for ~[A] {
+    pub fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
         let mut xs = with_capacity(lower);
         for x in iterator {
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
@@ -573,16 +573,16 @@ impl<A> DoubleEndedIterator<A> for MoveIterator<A> {
     fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
 }
 
-impl<A, T: Iterator<A>> FromIterator<A, T> for DList<A> {
-    fn from_iterator(iterator: &mut T) -> DList<A> {
+impl<A> FromIterator<A> for DList<A> {
+    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> DList<A> {
         let mut ret = DList::new();
         ret.extend(iterator);
         ret
     }
 }
 
-impl<A, T: Iterator<A>> Extendable<A, T> for DList<A> {
-    fn extend(&mut self, iterator: &mut T) {
+impl<A> Extendable<A> for DList<A> {
+    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
         for elt in *iterator { self.push_back(elt); }
     }
 }
@@ -1163,4 +1163,3 @@ mod tests {
         }
     }
 }
-
diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
@@ -190,17 +190,17 @@ impl<'self, T> Iterator<&'self T> for PriorityQueueIterator<'self, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
-impl<T: Ord, Iter: Iterator<T>> FromIterator<T, Iter> for PriorityQueue<T> {
-    fn from_iterator(iter: &mut Iter) -> PriorityQueue<T> {
+impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
+    fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> PriorityQueue<T> {
         let mut q = PriorityQueue::new();
         q.extend(iter);
 
         q
     }
 }
 
-impl<T: Ord, Iter: Iterator<T>> Extendable<T, Iter> for PriorityQueue<T> {
-    fn extend(&mut self, iter: &mut Iter) {
+impl<T: Ord> Extendable<T> for PriorityQueue<T> {
+    fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {
         let (lower, _) = iter.size_hint();
 
         let len = self.capacity();
diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs
@@ -322,17 +322,17 @@ impl<A: Eq> Eq for RingBuf<A> {
     }
 }
 
-impl<A, T: Iterator<A>> FromIterator<A, T> for RingBuf<A> {
-    fn from_iterator(iterator: &mut T) -> RingBuf<A> {
+impl<A> FromIterator<A> for RingBuf<A> {
+    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> RingBuf<A> {
         let (lower, _) = iterator.size_hint();
         let mut deq = RingBuf::with_capacity(lower);
         deq.extend(iterator);
         deq
     }
 }
 
-impl<A, T: Iterator<A>> Extendable<A, T> for RingBuf<A> {
-    fn extend(&mut self, iterator: &mut T) {
+impl<A> Extendable<A> for RingBuf<A> {
+    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
         for elt in *iterator {
             self.push_back(elt);
         }
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
@@ -835,34 +835,34 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     };
 }
 
-impl<K: TotalOrd, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for TreeMap<K, V> {
-    fn from_iterator(iter: &mut T) -> TreeMap<K, V> {
+impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {
+    fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> TreeMap<K, V> {
         let mut map = TreeMap::new();
         map.extend(iter);
         map
     }
 }
 
-impl<K: TotalOrd, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for TreeMap<K, V> {
+impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {
     #[inline]
-    fn extend(&mut self, iter: &mut T) {
+    fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {
         for (k, v) in *iter {
             self.insert(k, v);
         }
     }
 }
 
-impl<T: TotalOrd, Iter: Iterator<T>> FromIterator<T, Iter> for TreeSet<T> {
-    fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
+impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {
+    fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> TreeSet<T> {
         let mut set = TreeSet::new();
         set.extend(iter);
         set
     }
 }
 
-impl<T: TotalOrd, Iter: Iterator<T>> Extendable<T, Iter> for TreeSet<T> {
+impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
     #[inline]
-    fn extend(&mut self, iter: &mut Iter) {
+    fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {
         for elem in *iter {
             self.insert(elem);
         }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
@@ -605,17 +605,17 @@ impl<K> Iterator<K> for HashSetMoveIterator<K> {
     }
 }
 
-impl<K: Eq + Hash, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for HashMap<K, V> {
-    fn from_iterator(iter: &mut T) -> HashMap<K, V> {
+impl<K: Eq + Hash, V> FromIterator<(K, V)> for HashMap<K, V> {
+    fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V> {
         let (lower, _) = iter.size_hint();
         let mut map = HashMap::with_capacity(lower);
         map.extend(iter);
         map
     }
 }
 
-impl<K: Eq + Hash, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for HashMap<K, V> {
-    fn extend(&mut self, iter: &mut T) {
+impl<K: Eq + Hash, V> Extendable<(K, V)> for HashMap<K, V> {
+    fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {
         for (k, v) in *iter {
             self.insert(k, v);
         }
@@ -753,17 +753,17 @@ impl<T:Hash + Eq + Clone> Clone for HashSet<T> {
     }
 }
 
-impl<K: Eq + Hash, T: Iterator<K>> FromIterator<K, T> for HashSet<K> {
-    fn from_iterator(iter: &mut T) -> HashSet<K> {
+impl<K: Eq + Hash> FromIterator<K> for HashSet<K> {
+    fn from_iterator<T: Iterator<K>>(iter: &mut T) -> HashSet<K> {
         let (lower, _) = iter.size_hint();
         let mut set = HashSet::with_capacity(lower);
         set.extend(iter);
         set
     }
 }
 
-impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {
-    fn extend(&mut self, iter: &mut T) {
+impl<K: Eq + Hash> Extendable<K> for HashSet<K> {
+    fn extend<T: Iterator<K>>(&mut self, iter: &mut T) {
         for k in *iter {
             self.insert(k);
         }
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
@@ -26,15 +26,15 @@ use clone::Clone;
 use uint;
 
 /// Conversion from an `Iterator`
-pub trait FromIterator<A, T: Iterator<A>> {
+pub trait FromIterator<A> {
     /// Build a container with elements from an external iterator.
-    fn from_iterator(iterator: &mut T) -> Self;
+    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> Self;
 }
 
 /// A type growable from an `Iterator` implementation
-pub trait Extendable<A, T: Iterator<A>>: FromIterator<A, T> {
+pub trait Extendable<A>: FromIterator<A> {
     /// Extend a container with the elements yielded by an iterator
-    fn extend(&mut self, iterator: &mut T);
+    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T);
 }
 
 /// An interface for dealing with "external iterators". These types of iterators
@@ -353,7 +353,7 @@ pub trait Iterator<A> {
     /// assert!(a == b);
     /// ~~~
     #[inline]
-    fn collect<B: FromIterator<A, Self>>(&mut self) -> B {
+    fn collect<B: FromIterator<A>>(&mut self) -> B {
         FromIterator::from_iterator(self)
     }
 
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
@@ -2111,19 +2111,19 @@ impl Clone for @str {
     }
 }
 
-impl<T: Iterator<char>> FromIterator<char, T> for ~str {
+impl FromIterator<char> for ~str {
     #[inline]
-    fn from_iterator(iterator: &mut T) -> ~str {
+    fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {
         let (lower, _) = iterator.size_hint();
         let mut buf = with_capacity(lower);
         buf.extend(iterator);
         buf
     }
 }
 
-impl<T: Iterator<char>> Extendable<char, T> for ~str {
+impl Extendable<char> for ~str {
     #[inline]
-    fn extend(&mut self, iterator: &mut T) {
+    fn extend<T: Iterator<char>>(&mut self, iterator: &mut T) {
         let (lower, _) = iterator.size_hint();
         let reserve = lower + self.len();
         self.reserve_at_least(reserve);
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
@@ -205,16 +205,16 @@ impl<T> TrieMap<T> {
     }
 }
 
-impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T> {
-    fn from_iterator(iter: &mut Iter) -> TrieMap<T> {
+impl<T> FromIterator<(uint, T)> for TrieMap<T> {
+    fn from_iterator<Iter: Iterator<(uint, T)>>(iter: &mut Iter) -> TrieMap<T> {
         let mut map = TrieMap::new();
         map.extend(iter);
         map
     }
 }
 
-impl<T, Iter: Iterator<(uint, T)>> Extendable<(uint, T), Iter> for TrieMap<T> {
-    fn extend(&mut self, iter: &mut Iter) {
+impl<T> Extendable<(uint, T)> for TrieMap<T> {
+    fn extend<Iter: Iterator<(uint, T)>>(&mut self, iter: &mut Iter) {
         for (k, v) in *iter {
             self.insert(k, v);
         }
@@ -294,16 +294,16 @@ impl TrieSet {
     }
 }
 
-impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {
-    fn from_iterator(iter: &mut Iter) -> TrieSet {
+impl FromIterator<uint> for TrieSet {
+    fn from_iterator<Iter: Iterator<uint>>(iter: &mut Iter) -> TrieSet {
         let mut set = TrieSet::new();
         set.extend(iter);
         set
     }
 }
 
-impl<Iter: Iterator<uint>> Extendable<uint, Iter> for TrieSet {
-    fn extend(&mut self, iter: &mut Iter) {
+impl Extendable<uint> for TrieSet {
+    fn extend<Iter: Iterator<uint>>(&mut self, iter: &mut Iter) {
         for elem in *iter {
             self.insert(elem);
         }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
@@ -2316,8 +2316,8 @@ impl<T> Iterator<T> for MoveRevIterator<T> {
     }
 }
 
-impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
-    fn from_iterator(iterator: &mut T) -> ~[A] {
+impl<A> FromIterator<A> for ~[A] {
+    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
         let mut xs = with_capacity(lower);
         for x in *iterator {
@@ -2327,8 +2327,8 @@ impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
     }
 }
 
-impl<A, T: Iterator<A>> Extendable<A, T> for ~[A] {
-    fn extend(&mut self, iterator: &mut T) {
+impl<A> Extendable<A> for ~[A] {
+    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
         let (lower, _) = iterator.size_hint();
         let len = self.len();
         self.reserve(len + lower);

Original file line number	Diff line number	Diff line change
`@@ -573,16 +573,16 @@ impl<A> DoubleEndedIterator<A> for MoveIterator<A> {`
`573`	`573`	`fn next_back(&mut self) -> Option<A> { self.list.pop_back() }`
`574`	`574`	`}`
`575`	`575`
`576`		`-impl<A, T: Iterator<A>> FromIterator<A, T> for DList<A> {`
`577`		`- fn from_iterator(iterator: &mut T) -> DList<A> {`
	`576`	`+impl<A> FromIterator<A> for DList<A> {`
	`577`	`+ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> DList<A> {`
`578`	`578`	`let mut ret = DList::new();`
`579`	`579`	`ret.extend(iterator);`
`580`	`580`	`ret`
`581`	`581`	`}`
`582`	`582`	`}`
`583`	`583`
`584`		`-impl<A, T: Iterator<A>> Extendable<A, T> for DList<A> {`
`585`		`- fn extend(&mut self, iterator: &mut T) {`
	`584`	`+impl<A> Extendable<A> for DList<A> {`
	`585`	`+ fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {`
`586`	`586`	`for elt in *iterator { self.push_back(elt); }`
`587`	`587`	`}`
`588`	`588`	`}`
`@@ -1163,4 +1163,3 @@ mod tests {`
`1163`	`1163`	`}`
`1164`	`1164`	`}`
`1165`	`1165`	`}`
`1166`		`-`
Original file line number	Diff line number	Diff line change
`@@ -190,17 +190,17 @@ impl<'self, T> Iterator<&'self T> for PriorityQueueIterator<'self, T> {`
`190`	`190`	`fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }`
`191`	`191`	`}`
`192`	`192`
`193`		`-impl<T: Ord, Iter: Iterator<T>> FromIterator<T, Iter> for PriorityQueue<T> {`
`194`		`- fn from_iterator(iter: &mut Iter) -> PriorityQueue<T> {`
	`193`	`+impl<T: Ord> FromIterator<T> for PriorityQueue<T> {`
	`194`	`+ fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> PriorityQueue<T> {`
`195`	`195`	`let mut q = PriorityQueue::new();`
`196`	`196`	`q.extend(iter);`
`197`	`197`
`198`	`198`	`q`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`202`		`-impl<T: Ord, Iter: Iterator<T>> Extendable<T, Iter> for PriorityQueue<T> {`
`203`		`- fn extend(&mut self, iter: &mut Iter) {`
	`202`	`+impl<T: Ord> Extendable<T> for PriorityQueue<T> {`
	`203`	`+ fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {`
`204`	`204`	`let (lower, _) = iter.size_hint();`
`205`	`205`
`206`	`206`	`let len = self.capacity();`
Original file line number	Diff line number	Diff line change
`@@ -322,17 +322,17 @@ impl<A: Eq> Eq for RingBuf<A> {`
`322`	`322`	`}`
`323`	`323`	`}`
`324`	`324`
`325`		`-impl<A, T: Iterator<A>> FromIterator<A, T> for RingBuf<A> {`
`326`		`- fn from_iterator(iterator: &mut T) -> RingBuf<A> {`
	`325`	`+impl<A> FromIterator<A> for RingBuf<A> {`
	`326`	`+ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> RingBuf<A> {`
`327`	`327`	`let (lower, _) = iterator.size_hint();`
`328`	`328`	`let mut deq = RingBuf::with_capacity(lower);`
`329`	`329`	`deq.extend(iterator);`
`330`	`330`	`deq`
`331`	`331`	`}`
`332`	`332`	`}`
`333`	`333`
`334`		`-impl<A, T: Iterator<A>> Extendable<A, T> for RingBuf<A> {`
`335`		`- fn extend(&mut self, iterator: &mut T) {`
	`334`	`+impl<A> Extendable<A> for RingBuf<A> {`
	`335`	`+ fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {`
`336`	`336`	`for elt in *iterator {`
`337`	`337`	`self.push_back(elt);`
`338`	`338`	`}`
Original file line number	Diff line number	Diff line change
`@@ -835,34 +835,34 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,`
`835`	`835`	`};`
`836`	`836`	`}`
`837`	`837`
`838`		`-impl<K: TotalOrd, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for TreeMap<K, V> {`
`839`		`- fn from_iterator(iter: &mut T) -> TreeMap<K, V> {`
	`838`	`+impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {`
	`839`	`+ fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> TreeMap<K, V> {`
`840`	`840`	`let mut map = TreeMap::new();`
`841`	`841`	`map.extend(iter);`
`842`	`842`	`map`
`843`	`843`	`}`
`844`	`844`	`}`
`845`	`845`
`846`		`-impl<K: TotalOrd, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for TreeMap<K, V> {`
	`846`	`+impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {`
`847`	`847`	`#[inline]`
`848`		`- fn extend(&mut self, iter: &mut T) {`
	`848`	`+ fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {`
`849`	`849`	`for (k, v) in *iter {`
`850`	`850`	`self.insert(k, v);`
`851`	`851`	`}`
`852`	`852`	`}`
`853`	`853`	`}`
`854`	`854`
`855`		`-impl<T: TotalOrd, Iter: Iterator<T>> FromIterator<T, Iter> for TreeSet<T> {`
`856`		`- fn from_iterator(iter: &mut Iter) -> TreeSet<T> {`
	`855`	`+impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {`
	`856`	`+ fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> TreeSet<T> {`
`857`	`857`	`let mut set = TreeSet::new();`
`858`	`858`	`set.extend(iter);`
`859`	`859`	`set`
`860`	`860`	`}`
`861`	`861`	`}`
`862`	`862`
`863`		`-impl<T: TotalOrd, Iter: Iterator<T>> Extendable<T, Iter> for TreeSet<T> {`
	`863`	`+impl<T: TotalOrd> Extendable<T> for TreeSet<T> {`
`864`	`864`	`#[inline]`
`865`		`- fn extend(&mut self, iter: &mut Iter) {`
	`865`	`+ fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {`
`866`	`866`	`for elem in *iter {`
`867`	`867`	`self.insert(elem);`
`868`	`868`	`}`
Original file line number	Diff line number	Diff line change
`@@ -605,17 +605,17 @@ impl<K> Iterator<K> for HashSetMoveIterator<K> {`
`605`	`605`	`}`
`606`	`606`	`}`
`607`	`607`
`608`		`-impl<K: Eq + Hash, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for HashMap<K, V> {`
`609`		`- fn from_iterator(iter: &mut T) -> HashMap<K, V> {`
	`608`	`+impl<K: Eq + Hash, V> FromIterator<(K, V)> for HashMap<K, V> {`
	`609`	`+ fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V> {`
`610`	`610`	`let (lower, _) = iter.size_hint();`
`611`	`611`	`let mut map = HashMap::with_capacity(lower);`
`612`	`612`	`map.extend(iter);`
`613`	`613`	`map`
`614`	`614`	`}`
`615`	`615`	`}`
`616`	`616`
`617`		`-impl<K: Eq + Hash, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for HashMap<K, V> {`
`618`		`- fn extend(&mut self, iter: &mut T) {`
	`617`	`+impl<K: Eq + Hash, V> Extendable<(K, V)> for HashMap<K, V> {`
	`618`	`+ fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {`
`619`	`619`	`for (k, v) in *iter {`
`620`	`620`	`self.insert(k, v);`
`621`	`621`	`}`
`@@ -753,17 +753,17 @@ impl<T:Hash + Eq + Clone> Clone for HashSet<T> {`
`753`	`753`	`}`
`754`	`754`	`}`
`755`	`755`
`756`		`-impl<K: Eq + Hash, T: Iterator<K>> FromIterator<K, T> for HashSet<K> {`
`757`		`- fn from_iterator(iter: &mut T) -> HashSet<K> {`
	`756`	`+impl<K: Eq + Hash> FromIterator<K> for HashSet<K> {`
	`757`	`+ fn from_iterator<T: Iterator<K>>(iter: &mut T) -> HashSet<K> {`
`758`	`758`	`let (lower, _) = iter.size_hint();`
`759`	`759`	`let mut set = HashSet::with_capacity(lower);`
`760`	`760`	`set.extend(iter);`
`761`	`761`	`set`
`762`	`762`	`}`
`763`	`763`	`}`
`764`	`764`
`765`		`-impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {`
`766`		`- fn extend(&mut self, iter: &mut T) {`
	`765`	`+impl<K: Eq + Hash> Extendable<K> for HashSet<K> {`
	`766`	`+ fn extend<T: Iterator<K>>(&mut self, iter: &mut T) {`
`767`	`767`	`for k in *iter {`
`768`	`768`	`self.insert(k);`
`769`	`769`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2111,19 +2111,19 @@ impl Clone for @str {`
`2111`	`2111`	`}`
`2112`	`2112`	`}`
`2113`	`2113`
`2114`		`-impl<T: Iterator<char>> FromIterator<char, T> for ~str {`
	`2114`	`+impl FromIterator<char> for ~str {`
`2115`	`2115`	`#[inline]`
`2116`		`- fn from_iterator(iterator: &mut T) -> ~str {`
	`2116`	`+ fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {`
`2117`	`2117`	`let (lower, _) = iterator.size_hint();`
`2118`	`2118`	`let mut buf = with_capacity(lower);`
`2119`	`2119`	`buf.extend(iterator);`
`2120`	`2120`	`buf`
`2121`	`2121`	`}`
`2122`	`2122`	`}`
`2123`	`2123`
`2124`		`-impl<T: Iterator<char>> Extendable<char, T> for ~str {`
	`2124`	`+impl Extendable<char> for ~str {`
`2125`	`2125`	`#[inline]`
`2126`		`- fn extend(&mut self, iterator: &mut T) {`
	`2126`	`+ fn extend<T: Iterator<char>>(&mut self, iterator: &mut T) {`
`2127`	`2127`	`let (lower, _) = iterator.size_hint();`
`2128`	`2128`	`let reserve = lower + self.len();`
`2129`	`2129`	`self.reserve_at_least(reserve);`
Original file line number	Diff line number	Diff line change
`@@ -205,16 +205,16 @@ impl<T> TrieMap<T> {`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`208`		`-impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T> {`
`209`		`- fn from_iterator(iter: &mut Iter) -> TrieMap<T> {`
	`208`	`+impl<T> FromIterator<(uint, T)> for TrieMap<T> {`
	`209`	`+ fn from_iterator<Iter: Iterator<(uint, T)>>(iter: &mut Iter) -> TrieMap<T> {`
`210`	`210`	`let mut map = TrieMap::new();`
`211`	`211`	`map.extend(iter);`
`212`	`212`	`map`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`
`216`		`-impl<T, Iter: Iterator<(uint, T)>> Extendable<(uint, T), Iter> for TrieMap<T> {`
`217`		`- fn extend(&mut self, iter: &mut Iter) {`
	`216`	`+impl<T> Extendable<(uint, T)> for TrieMap<T> {`
	`217`	`+ fn extend<Iter: Iterator<(uint, T)>>(&mut self, iter: &mut Iter) {`
`218`	`218`	`for (k, v) in *iter {`
`219`	`219`	`self.insert(k, v);`
`220`	`220`	`}`
`@@ -294,16 +294,16 @@ impl TrieSet {`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`
`297`		`-impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {`
`298`		`- fn from_iterator(iter: &mut Iter) -> TrieSet {`
	`297`	`+impl FromIterator<uint> for TrieSet {`
	`298`	`+ fn from_iterator<Iter: Iterator<uint>>(iter: &mut Iter) -> TrieSet {`
`299`	`299`	`let mut set = TrieSet::new();`
`300`	`300`	`set.extend(iter);`
`301`	`301`	`set`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`		`-impl<Iter: Iterator<uint>> Extendable<uint, Iter> for TrieSet {`
`306`		`- fn extend(&mut self, iter: &mut Iter) {`
	`305`	`+impl Extendable<uint> for TrieSet {`
	`306`	`+ fn extend<Iter: Iterator<uint>>(&mut self, iter: &mut Iter) {`
`307`	`307`	`for elem in *iter {`
`308`	`308`	`self.insert(elem);`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2316,8 +2316,8 @@ impl<T> Iterator<T> for MoveRevIterator<T> {`
`2316`	`2316`	`}`
`2317`	`2317`	`}`
`2318`	`2318`
`2319`		`-impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {`
`2320`		`- fn from_iterator(iterator: &mut T) -> ~[A] {`
	`2319`	`+impl<A> FromIterator<A> for ~[A] {`
	`2320`	`+ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {`
`2321`	`2321`	`let (lower, _) = iterator.size_hint();`
`2322`	`2322`	`let mut xs = with_capacity(lower);`
`2323`	`2323`	`for x in *iterator {`
`@@ -2327,8 +2327,8 @@ impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {`
`2327`	`2327`	`}`
`2328`	`2328`	`}`
`2329`	`2329`
`2330`		`-impl<A, T: Iterator<A>> Extendable<A, T> for ~[A] {`
`2331`		`- fn extend(&mut self, iterator: &mut T) {`
	`2330`	`+impl<A> Extendable<A> for ~[A] {`
	`2331`	`+ fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {`
`2332`	`2332`	`let (lower, _) = iterator.size_hint();`
`2333`	`2333`	`let len = self.len();`
`2334`	`2334`	`self.reserve(len + lower);`