diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index dd3a639aeac78..263d6338a6584 100644
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -405,17 +405,26 @@ impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
     }
 }
 
-impl<V> FromIterator<(uint, V)> for SmallIntMap<V> {
-    fn from_iter<Iter: Iterator<(uint, V)>>(iter: Iter) -> SmallIntMap<V> {
+impl<V, U: Extendable<V>> FromIterator<(uint, V)> for SmallIntMap<U> {
+    fn from_iter<Iter: Iterator<(uint, V)>>(iter: Iter) -> SmallIntMap<U> {
         let mut map = SmallIntMap::new();
         map.extend(iter);
         map
     }
 }
 
-impl<V> Extendable<(uint, V)> for SmallIntMap<V> {
+impl<V, U: Extendable<V>> Extendable<(uint, V)> for SmallIntMap<U> {
     fn extend<Iter: Iterator<(uint, V)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
+            match self.find_mut(&k) {
+                Some(found) => {
+                    found.extend(Some(v).move_iter());
+                    continue
+                },
+                None => {} // Insert below
+            }
+
+            let v = FromIterator::from_iter(Some(v).move_iter());
             self.insert(k, v);
         }
     }
@@ -856,12 +865,21 @@ mod test_map {
 
     #[test]
     fn test_from_iter() {
-        let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
+        let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'),
+                                         (4, 'd'), (5, 'e'), (3, 'f')];
+
+        let expected = vec![
+            (1u, vec!['a']),
+            (2u, vec!['b']),
+            (3u, vec!['c', 'f']),
+            (4u, vec!['d']),
+            (5u, vec!['e']),
+        ];
 
-        let map: SmallIntMap<char> = xs.iter().map(|&x| x).collect();
+        let map: SmallIntMap<Vec<char>> = xs.iter().map(|&x| x).collect();
 
-        for &(k, v) in xs.iter() {
-            assert_eq!(map.find(&k), Some(&v));
+        for &(k, ref v) in expected.iter() {
+            assert_eq!(map.find(&k), Some(v))
         }
     }
 
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index 80a7c6d4bad1d..149fdcafaf22b 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -1617,18 +1617,27 @@ fn remove<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
     };
 }
 
-impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
-    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
+impl<K: Ord, V, U: Extendable<V>> FromIterator<(K, V)> for TreeMap<K, U> {
+    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, U> {
         let mut map = TreeMap::new();
         map.extend(iter);
         map
     }
 }
 
-impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
+impl<K: Ord, V, U: Extendable<V>> Extendable<(K, V)> for TreeMap<K, U> {
     #[inline]
     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {
+            match self.find_mut(&k) {
+                Some(found) => {
+                    found.extend(Some(v).move_iter());
+                    continue
+                }
+                None => {}
+            }
+
+            let v = FromIterator::from_iter(Some(v).move_iter());
             self.insert(k, v);
         }
     }
@@ -2020,7 +2029,11 @@ mod test_treemap {
     #[test]
     fn test_keys() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<TreeMap<int, char>>();
+        let mut map = TreeMap::new();
+        for (k, v) in vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
@@ -2031,7 +2044,11 @@ mod test_treemap {
     #[test]
     fn test_values() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<TreeMap<int, char>>();
+        let mut map = TreeMap::new();
+        for (k, v) in vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let values = map.values().map(|&v| v).collect::<Vec<char>>();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
@@ -2152,13 +2169,12 @@ mod test_treemap {
 
     #[test]
     fn test_from_iter() {
-        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = vec![(1, 'H'), (2, 'B'), (3, 'i'), (4, 'y'), (5, '!'), (6, 'e')];
 
-        let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
+        let map = xs.iter().map(|&(k, v)| (k % 2, v)).collect::<TreeMap<int, String>>();
 
-        for &(k, v) in xs.iter() {
-            assert_eq!(map.find(&k), Some(&v));
-        }
+        assert_eq!(map.find(&1).map(|s| s.as_slice()), Some("Hi!"));
+        assert_eq!(map.find(&0).map(|s| s.as_slice()), Some("Bye"));
     }
 
     #[test]
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index fa8bcf94de1cd..5eabcaaef66a3 100644
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -212,7 +212,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let map: TrieMap<&str> = [(1, "a"), (2, "b"), (3, "c")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(1, "a"), (2, "b"), (3, "c")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// let mut vec = Vec::new();
     /// assert_eq!(true, map.each_reverse(|&key, &value| { vec.push((key, value)); true }));
@@ -246,7 +249,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let map: TrieMap<&str> = [(3, "c"), (1, "a"), (2, "b")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(3, "c"), (1, "a"), (2, "b")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// for (key, value) in map.iter() {
     ///     println!("{}: {}", key, value);
@@ -269,7 +275,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let mut map: TrieMap<int> = [(1, 2), (2, 4), (3, 6)].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<int>::new();
+    /// for &(k, v) in [(1, 2), (2, 4), (3, 6)].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// for (key, value) in map.mut_iter() {
     ///     *value = -(key as int);
@@ -392,7 +401,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(2, "a"), (4, "b"), (6, "c")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// assert_eq!(map.lower_bound(4).next(), Some((4, &"b")));
     /// assert_eq!(map.lower_bound(5).next(), Some((6, &"c")));
@@ -409,7 +421,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(2, "a"), (4, "b"), (6, "c")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// assert_eq!(map.upper_bound(4).next(), Some((6, &"c")));
     /// assert_eq!(map.upper_bound(5).next(), Some((6, &"c")));
@@ -434,7 +449,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(2, "a"), (4, "b"), (6, "c")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// assert_eq!(map.mut_lower_bound(4).next(), Some((4, &mut "b")));
     /// assert_eq!(map.mut_lower_bound(5).next(), Some((6, &mut "c")));
@@ -459,7 +477,10 @@ impl<T> TrieMap<T> {
     ///
     /// ```
     /// use std::collections::TrieMap;
-    /// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
+    /// let mut map = TrieMap::<&str>::new();
+    /// for &(k, v) in [(2, "a"), (4, "b"), (6, "c")].iter() {
+    ///     map.insert(k, v);
+    /// }
     ///
     /// assert_eq!(map.mut_upper_bound(4).next(), Some((6, &mut "c")));
     /// assert_eq!(map.mut_upper_bound(5).next(), Some((6, &mut "c")));
@@ -478,17 +499,26 @@ impl<T> TrieMap<T> {
     }
 }
 
-impl<T> FromIterator<(uint, T)> for TrieMap<T> {
-    fn from_iter<Iter: Iterator<(uint, T)>>(iter: Iter) -> TrieMap<T> {
+impl<T, U: Extendable<T>> FromIterator<(uint, T)> for TrieMap<U> {
+    fn from_iter<Iter: Iterator<(uint, T)>>(iter: Iter) -> TrieMap<U> {
         let mut map = TrieMap::new();
         map.extend(iter);
         map
     }
 }
 
-impl<T> Extendable<(uint, T)> for TrieMap<T> {
+impl<T, U: Extendable<T>> Extendable<(uint, T)> for TrieMap<U> {
     fn extend<Iter: Iterator<(uint, T)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
+            match self.find_mut(&k) {
+                Some(found) => {
+                    found.extend(Some(v).move_iter());
+                    continue
+                }
+                None => {}
+            }
+
+            let v = FromIterator::from_iter(Some(v).move_iter());
             self.insert(k, v);
         }
     }
@@ -1160,19 +1190,22 @@ mod test_map {
 
     #[test]
     fn test_from_iter() {
-        let xs = vec![(1u, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = vec![(1, 'H'), (2, 'B'), (3, 'i'), (4, 'y'), (5, '!'), (6, 'e')];
 
-        let map: TrieMap<int> = xs.iter().map(|&x| x).collect();
+        let map = xs.iter().map(|&(k, v)| (k % 2, v)).collect::<TrieMap<String>>();
 
-        for &(k, v) in xs.iter() {
-            assert_eq!(map.find(&k), Some(&v));
-        }
+        assert_eq!(map.find(&1).map(|s| s.as_slice()), Some("Hi!"));
+        assert_eq!(map.find(&0).map(|s| s.as_slice()), Some("Bye"));
     }
 
     #[test]
     fn test_keys() {
         let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.move_iter().collect::<TrieMap<char>>();
+        let mut map = TrieMap::new();
+        for (k, v) in vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let keys = map.keys().collect::<Vec<uint>>();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
@@ -1183,7 +1216,11 @@ mod test_map {
     #[test]
     fn test_values() {
         let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.move_iter().collect::<TrieMap<char>>();
+        let mut map = TrieMap::new();
+        for (k, v) in vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let values = map.values().map(|&v| v).collect::<Vec<char>>();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
index 26ed5cbfb2cc1..ef9d780186a75 100644
--- a/src/librustc/lint/context.rs
+++ b/src/librustc/lint/context.rs
@@ -212,14 +212,13 @@ impl LintStore {
             match self.by_name.find_equiv(&lint_name.as_slice()) {
                 Some(&lint_id) => self.set_level(lint_id, (level, CommandLine)),
                 None => {
-                    match self.lint_groups.iter().map(|(&x, pair)| (x, pair.ref0().clone()))
-                                                 .collect::<HashMap<&'static str, Vec<LintId>>>()
-                                                 .find_equiv(&lint_name.as_slice()) {
+                    match self.lint_groups.iter()
+                                          .find(|&(&x, _)| x == lint_name.as_slice())
+                                          .map(|(_, pair)| pair.ref0().clone()) {
                         Some(v) => {
-                            v.iter()
-                             .map(|lint_id: &LintId|
-                                     self.set_level(*lint_id, (level, CommandLine)))
-                             .collect::<Vec<()>>();
+                            for &lint_id in v.iter() {
+                                self.set_level(lint_id, (level, CommandLine))
+                            }
                         }
                         None => sess.err(format!("unknown {} flag: {}",
                                                  level.as_str(), lint_name).as_slice()),
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 321eee3d5fcef..d3ed49ec1d155 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -404,15 +404,17 @@ fn resolve_crate_deps(e: &mut Env,
     debug!("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
-    decoder::get_crate_deps(cdata).iter().map(|dep| {
+    let mut map = HashMap::new();
+    for dep in decoder::get_crate_deps(cdata).iter() {
         debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash);
         let (local_cnum, _, _) = resolve_crate(e, root,
                                                dep.name.as_slice(),
                                                dep.name.as_slice(),
                                                Some(&dep.hash),
                                                span);
-        (dep.cnum, local_cnum)
-    }).collect()
+        map.insert(dep.cnum, local_cnum);
+    }
+    map
 }
 
 pub struct PluginMetadataReader<'a> {
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 77e0a641e181d..3fe79c6af8de2 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -295,11 +295,13 @@ pub fn run(mut krate: clean::Crate, external_html: &ExternalHtml, dst: Path) ->
     let analysis = ::analysiskey.get();
     let public_items = analysis.as_ref().map(|a| a.public_items.clone());
     let public_items = public_items.unwrap_or(NodeSet::new());
-    let paths: HashMap<ast::DefId, (Vec<String>, ItemType)> =
-      analysis.as_ref().map(|a| {
-        let paths = a.external_paths.borrow_mut().take().unwrap();
-        paths.move_iter().map(|(k, (v, t))| {
-            (k, (v, match t {
+    let mut paths = HashMap::<ast::DefId, (Vec<String>, ItemType)>::new();
+
+    for a in analysis.as_ref().iter() {
+        let ext_paths = a.external_paths.borrow_mut().take().unwrap();
+
+        for (k, (v, t)) in ext_paths.move_iter() {
+            paths.insert(k, (v, match t {
                 clean::TypeStruct => item_type::Struct,
                 clean::TypeEnum => item_type::Enum,
                 clean::TypeFunction => item_type::Function,
@@ -307,13 +309,18 @@ pub fn run(mut krate: clean::Crate, external_html: &ExternalHtml, dst: Path) ->
                 clean::TypeModule => item_type::Module,
                 clean::TypeStatic => item_type::Static,
                 clean::TypeVariant => item_type::Variant,
-            }))
-        }).collect()
-    }).unwrap_or(HashMap::new());
+            }));
+        }
+    }
+
+    let mut external_paths = HashMap::new();
+    for (&k, v) in paths.iter() {
+        external_paths.insert(k, v.ref0().clone());
+    }
+
     let mut cache = Cache {
         impls: HashMap::new(),
-        external_paths: paths.iter().map(|(&k, v)| (k, v.ref0().clone()))
-                             .collect(),
+        external_paths: external_paths,
         paths: paths,
         implementors: HashMap::new(),
         stack: Vec::new(),
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 758af6758c2c4..7f4f4fffd6e41 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -30,7 +30,7 @@ extern crate time;
 
 use std::io;
 use std::io::{File, MemWriter};
-use std::collections::HashMap;
+use std::collections::{HashMap, TreeMap};
 use serialize::{json, Decodable, Encodable};
 use externalfiles::ExternalHtml;
 
@@ -494,15 +494,17 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
     // }
     let mut json = std::collections::TreeMap::new();
     json.insert("schema".to_string(), json::String(SCHEMA_VERSION.to_string()));
-    let plugins_json = res.move_iter()
-                          .filter_map(|opt| {
-                              match opt {
-                                  None => None,
-                                  Some((string, json)) => {
-                                      Some((string.to_string(), json))
-                                  }
-                              }
-                          }).collect();
+
+    let mut plugins_json = TreeMap::new();
+
+    for opt in res.move_iter() {
+        match opt {
+            Some((string, json)) => {
+                plugins_json.insert(string.to_string(), json);
+            },
+            None => {}
+        }
+    }
 
     // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode
     // straight to the Rust JSON representation.
diff --git a/src/libstd/collections/hashmap/map.rs b/src/libstd/collections/hashmap/map.rs
index a50c6a59f7e04..bf00f213e06e1 100644
--- a/src/libstd/collections/hashmap/map.rs
+++ b/src/libstd/collections/hashmap/map.rs
@@ -1382,8 +1382,12 @@ pub type Keys<'a, K, V> =
 pub type Values<'a, K, V> =
     iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
 
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
-    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {
+impl<K: Eq + Hash<S>,
+     V,
+     S,
+     H: Hasher<S> + Default,
+     U: Extendable<V>> FromIterator<(K, V)> for HashMap<K, U, H> {
+    fn from_iter<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, U, H> {
         let (lower, _) = iter.size_hint();
         let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
         map.extend(iter);
@@ -1391,9 +1395,22 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for Has
     }
 }
 
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashMap<K, V, H> {
+impl<K: Eq + Hash<S>,
+     V,
+     S,
+     H: Hasher<S> + Default,
+     U: Extendable<V>> Extendable<(K, V)> for HashMap<K, U, H> {
     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {
+            match self.find_mut(&k) {
+                Some(found) => {
+                    found.extend(Some(v).move_iter());
+                    continue
+                }
+                None => {}
+            }
+
+            let v = FromIterator::from_iter(Some(v).move_iter());
             self.insert(k, v);
         }
     }
@@ -1785,7 +1802,11 @@ mod test_map {
     #[test]
     fn test_keys() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<HashMap<int, char>>();
+        let mut map = HashMap::new();
+        for (k, v) in  vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
@@ -1796,7 +1817,11 @@ mod test_map {
     #[test]
     fn test_values() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<HashMap<int, char>>();
+        let mut map = HashMap::new();
+        for (k, v) in vec.move_iter() {
+            map.insert(k, v);
+        }
+
         let values = map.values().map(|&v| v).collect::<Vec<char>>();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
@@ -1957,20 +1982,22 @@ mod test_map {
 
     #[test]
     fn test_from_iter() {
-        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = vec![(1, 'H'), (2, 'B'), (3, 'i'), (4, 'y'), (5, '!'), (6, 'e')];
 
-        let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let map = xs.iter().map(|&(k, v)| (k % 2, v)).collect::<HashMap<int, String>>();
 
-        for &(k, v) in xs.iter() {
-            assert_eq!(map.find(&k), Some(&v));
-        }
+        assert_eq!(map.find(&1).map(|s| s.as_slice()), Some("Hi!"));
+        assert_eq!(map.find(&0).map(|s| s.as_slice()), Some("Bye"));
     }
 
     #[test]
     fn test_size_hint() {
         let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map = HashMap::new();
+        for (k, v) in xs.iter().map(|&x| x) {
+            map.insert(k, v);
+        }
 
         let mut iter = map.iter();
 
@@ -1983,7 +2010,10 @@ mod test_map {
     fn test_mut_size_hint() {
         let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map = HashMap::new();
+        for (k, v) in xs.iter().map(|&x| x) {
+            map.insert(k, v);
+        }
 
         let mut iter = map.mut_iter();
 
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index c1f4161fe181f..d5c04e7ae33ab 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -167,10 +167,13 @@ impl Command {
             None => {
                 // if the env is currently just inheriting from the parent's,
                 // materialize the parent's env into a hashtable.
-                self.env = Some(os::env_as_bytes().move_iter()
-                                   .map(|(k, v)| (k.as_slice().to_c_str(),
-                                                  v.as_slice().to_c_str()))
-                                   .collect());
+                let mut map = HashMap::new();
+                for (k, v) in os::env_as_bytes().move_iter() {
+                    map.insert(k.as_slice().to_c_str(),
+                               v.as_slice().to_c_str());
+                }
+
+                self.env = Some(map);
                 self.env.as_mut().unwrap()
             }
         }
@@ -195,8 +198,12 @@ impl Command {
     /// variable, the *rightmost* instance will determine the value.
     pub fn env_set_all<'a, T: ToCStr, U: ToCStr>(&'a mut self, env: &[(T,U)])
                                                  -> &'a mut Command {
-        self.env = Some(env.iter().map(|&(ref k, ref v)| (k.to_c_str(), v.to_c_str()))
-                                  .collect());
+        let mut map = HashMap::new();
+        for &(ref k, ref v) in env.iter() {
+            map.insert(k.to_c_str(), v.to_c_str());
+        }
+
+        self.env = Some(map);
         self
     }
 
diff --git a/src/libsyntax/diagnostics/registry.rs b/src/libsyntax/diagnostics/registry.rs
index 7bc191df55af3..e0f073d7828d2 100644
--- a/src/libsyntax/diagnostics/registry.rs
+++ b/src/libsyntax/diagnostics/registry.rs
@@ -16,7 +16,12 @@ pub struct Registry {
 
 impl Registry {
     pub fn new(descriptions: &[(&'static str, &'static str)]) -> Registry {
-        Registry { descriptions: descriptions.iter().map(|&tuple| tuple).collect() }
+        let mut map = HashMap::new();
+        for &(k, v) in descriptions.iter() {
+            map.insert(k, v);
+        }
+
+        Registry { descriptions: map }
     }
 
     pub fn find_description(&self, code: &str) -> Option<&'static str> {