auto merge of #9065 : thestinger/rust/iter, r=alexcrichton

The trait will keep the `Iterator` naming, but a more concise module
name makes using the free functions less verbose. The module will define
iterables in addition to iterators, as it deals with iteration in
general.

48 files changed, 89 insertions, 95 deletions

diff --git a/doc/tutorial-container.md b/doc/tutorial-container.md
index 7851e9852c1..4ec9ac4b45a 100644
--- a/doc/tutorial-container.md
+++ b/doc/tutorial-container.md
@@ -200,7 +200,7 @@ for i in range(0, 5) {
   printf!("%d ", i) // prints "0 1 2 3 4"
 }
 
-for i in std::iterator::range_inclusive(0, 5) { // needs explicit import
+for i in std::iter::range_inclusive(0, 5) { // needs explicit import
   printf!("%d ", i) // prints "0 1 2 3 4 5"
 }
 ~~~
diff --git a/src/etc/unicode.py b/src/etc/unicode.py
index d7c2016912c..a58c5767ead 100755
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@@ -310,7 +310,7 @@ def emit_decomp_module(f, canon, compat, combine):
         + "        bsearch_range_value_table(c, combining_class_table)\n"
         + "    }\n\n")
     f.write("    fn d(c: char, i: &fn(char), k: bool) {\n")
-    f.write("        use iterator::Iterator;\n");
+    f.write("        use iter::Iterator;\n");
 
     f.write("        if c <= '\\x7f' { i(c); return; }\n")
 
diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
index 70fd3a01ca4..780527e4532 100644
--- a/src/libextra/bitv.rs
+++ b/src/libextra/bitv.rs
@@ -12,8 +12,8 @@
 
 
 use std::cmp;
-use std::iterator::RandomAccessIterator;
-use std::iterator::{Invert, Enumerate, Repeat, Map, Zip};
+use std::iter::RandomAccessIterator;
+use std::iter::{Invert, Enumerate, Repeat, Map, Zip};
 use std::num;
 use std::ops;
 use std::uint;
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index 64bb17a6271..ac296ad527e 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -25,8 +25,8 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iterator::{FromIterator, Extendable, Invert};
-use std::iterator;
+use std::iter::Invert;
+use std::iter;
 
 use container::Deque;
 
@@ -593,27 +593,27 @@ impl<A> Extendable<A> for DList<A> {
 impl<A: Eq> Eq for DList<A> {
     fn eq(&self, other: &DList<A>) -> bool {
         self.len() == other.len() &&
-            iterator::order::eq(self.iter(), other.iter())
+            iter::order::eq(self.iter(), other.iter())
     }
 
     fn ne(&self, other: &DList<A>) -> bool {
         self.len() != other.len() ||
-            iterator::order::ne(self.iter(), other.iter())
+            iter::order::ne(self.iter(), other.iter())
     }
 }
 
 impl<A: Eq + Ord> Ord for DList<A> {
     fn lt(&self, other: &DList<A>) -> bool {
-        iterator::order::lt(self.iter(), other.iter())
+        iter::order::lt(self.iter(), other.iter())
     }
     fn le(&self, other: &DList<A>) -> bool {
-        iterator::order::le(self.iter(), other.iter())
+        iter::order::le(self.iter(), other.iter())
     }
     fn gt(&self, other: &DList<A>) -> bool {
-        iterator::order::gt(self.iter(), other.iter())
+        iter::order::gt(self.iter(), other.iter())
     }
     fn ge(&self, other: &DList<A>) -> bool {
-        iterator::order::ge(self.iter(), other.iter())
+        iter::order::ge(self.iter(), other.iter())
     }
 }
 
diff --git a/src/libextra/enum_set.rs b/src/libextra/enum_set.rs
index 2b1246b0af0..242faa2b4da 100644
--- a/src/libextra/enum_set.rs
+++ b/src/libextra/enum_set.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::iterator::Iterator;
-
 #[deriving(Clone, Eq, IterBytes, ToStr)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index ee3e1966fe2..f76dc05b277 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -18,7 +18,6 @@
 
 use std::char;
 use std::cast::transmute;
-use std::iterator;
 use std::float;
 use std::hashmap::HashMap;
 use std::io::WriterUtil;
@@ -489,7 +488,7 @@ pub struct Parser<T> {
 }
 
 /// Decode a json value from an Iterator<char>
-pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
+pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
     let mut p = Parser {
         rdr: rdr,
         ch: '\x00',
@@ -500,7 +499,7 @@ pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
     p
 }
 
-impl<T: iterator::Iterator<char>> Parser<T> {
+impl<T: Iterator<char>> Parser<T> {
     pub fn parse(&mut self) -> Result<Json, Error> {
         match self.parse_value() {
           Ok(value) => {
@@ -518,7 +517,7 @@ impl<T: iterator::Iterator<char>> Parser<T> {
     }
 }
 
-impl<T : iterator::Iterator<char>> Parser<T> {
+impl<T : Iterator<char>> Parser<T> {
     // FIXME: #8971: unsound
     fn eof(&self) -> bool { self.ch == unsafe { transmute(-1u32) } }
 
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index cb764228155..2e61b7fdbdc 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -2011,13 +2011,13 @@ mod bigint_tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use std::{iterator, util};
+    use std::{iter, util};
     use std::num::{Zero, One};
     use extra::test::BenchHarness;
 
     fn factorial(n: uint) -> BigUint {
         let mut f: BigUint = One::one();
-        for i in iterator::range_inclusive(1, n) {
+        for i in iter::range_inclusive(1, n) {
             f = f * BigUint::from_uint(i);
         }
         f
diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
index b085981aabb..6dd4759d927 100644
--- a/src/libextra/priority_queue.rs
+++ b/src/libextra/priority_queue.rs
@@ -16,7 +16,6 @@ use std::clone::Clone;
 use std::unstable::intrinsics::{move_val_init, init};
 use std::util::{replace, swap};
 use std::vec;
-use std::iterator::{FromIterator, Extendable};
 
 /// A priority queue implemented with a binary heap
 #[deriving(Clone)]
diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs
index 9ae9b47e207..ea8537caeb5 100644
--- a/src/libextra/ringbuf.rs
+++ b/src/libextra/ringbuf.rs
@@ -15,7 +15,7 @@
 
 use std::num;
 use std::vec;
-use std::iterator::{FromIterator, Invert, RandomAccessIterator, Extendable};
+use std::iter::{Invert, RandomAccessIterator};
 
 use container::Deque;
 
@@ -694,13 +694,13 @@ mod tests {
 
     #[test]
     fn test_from_iterator() {
-        use std::iterator;
+        use std::iter;
         let v = ~[1,2,3,4,5,6,7];
         let deq: RingBuf<int> = v.iter().map(|&x| x).collect();
         let u: ~[int] = deq.iter().map(|&x| x).collect();
         assert_eq!(u, v);
 
-        let mut seq = iterator::count(0u, 2).take(256);
+        let mut seq = iter::count(0u, 2).take(256);
         let deq: RingBuf<uint> = seq.collect();
         for (i, &x) in deq.iter().enumerate() {
             assert_eq!(2*i, x);
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index ac07fd2bebf..983247971d3 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use std::iterator::{Iterator, Enumerate, FilterMap, Invert};
+use std::iter::{Enumerate, FilterMap, Invert};
 use std::util::replace;
 use std::vec::{VecIterator, VecMutIterator};
 use std::vec;
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 307de43a067..99643e643b7 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -14,7 +14,7 @@
 
 
 use std::util::{swap, replace};
-use std::iterator::{FromIterator, Extendable, Peekable};
+use std::iter::{Peekable};
 use std::cmp::Ordering;
 
 // This is implemented as an AA tree, which is a simplified variation of
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 14a4601e415..581e203ae9a 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -18,7 +18,7 @@ use middle::typeck::method_map;
 use middle::moves;
 use util::ppaux::ty_to_str;
 
-use std::iterator;
+use std::iter;
 use std::num;
 use std::vec;
 use extra::sort;
@@ -282,7 +282,7 @@ pub fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful {
                     _ => max_len
                   }
                 };
-                for n in iterator::range(0u, max_len + 1) {
+                for n in iter::range(0u, max_len + 1) {
                   match is_useful_specialized(cx, m, v, vec(n), n, left_ty) {
                     not_useful => (),
                     ref u => return *u,
diff --git a/src/librustc/middle/trans/basic_block.rs b/src/librustc/middle/trans/basic_block.rs
index 8ca18d81245..14ba9244260 100644
--- a/src/librustc/middle/trans/basic_block.rs
+++ b/src/librustc/middle/trans/basic_block.rs
@@ -10,7 +10,7 @@
 
 use lib::llvm::{llvm, BasicBlockRef};
 use middle::trans::value::{UserIterator, Value};
-use std::iterator::{Filter, Map};
+use std::iter::{Filter, Map};
 
 pub struct BasicBlock(BasicBlockRef);
 
diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index c192803efff..d69ed5d9102 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use container::Container;
-use iterator::Iterator;
+use iter::Iterator;
 use option::{Option, Some, None};
 use sys;
 use unstable::raw::Repr;
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index 6f12e219c3c..51b70a07be8 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 use cast;
-use iterator::{Iterator,range};
+use iter::{Iterator, range};
 use libc;
 use ops::Drop;
 use option::{Option, Some, None};
 use ptr::RawPtr;
 use ptr;
 use str::StrSlice;
-use vec::{ImmutableVector,CopyableVector};
+use vec::{ImmutableVector, CopyableVector};
 use container::Container;
 
 /// Resolution options for the `null_byte` condition
diff --git a/src/libstd/either.rs b/src/libstd/either.rs
index 5d988965e8c..ec9e6d1ca4b 100644
--- a/src/libstd/either.rs
+++ b/src/libstd/either.rs
@@ -16,7 +16,7 @@ use option::{Some, None};
 use clone::Clone;
 use container::Container;
 use cmp::Eq;
-use iterator::{Iterator, FilterMap};
+use iter::{Iterator, FilterMap};
 use result::Result;
 use result;
 use str::StrSlice;
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index ef036340412..7d5033e3a6a 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -812,7 +812,7 @@ macro_rules! upper_hex(($ty:ident, $into:ident) => {
 #[doc(hidden)]
 pub fn upperhex(buf: &[u8], f: &mut Formatter) {
     let mut local = [0u8, ..16];
-    for i in ::iterator::range(0, buf.len()) {
+    for i in ::iter::range(0, buf.len()) {
         local[i] = match buf[i] as char {
             'a' .. 'f' => (buf[i] - 'a' as u8) + 'A' as u8,
             c => c as u8,
diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs
index 245318c4699..fd0e86d7a31 100644
--- a/src/libstd/fmt/parse.rs
+++ b/src/libstd/fmt/parse.rs
@@ -12,7 +12,6 @@ use prelude::*;
 
 use char;
 use str;
-use iterator;
 
 condition! { pub parse_error: ~str -> (); }
 
@@ -152,7 +151,7 @@ pub struct Parser<'self> {
     priv depth: uint,
 }
 
-impl<'self> iterator::Iterator<Piece<'self>> for Parser<'self> {
+impl<'self> Iterator<Piece<'self>> for Parser<'self> {
     fn next(&mut self) -> Option<Piece<'self>> {
         match self.cur.clone().next() {
             Some((_, '#')) => { self.cur.next(); Some(CurrentArgument) }
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index 6682a410979..4cce9995328 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -22,7 +22,7 @@
 #[allow(missing_doc)];
 
 use container::Container;
-use iterator::Iterator;
+use iter::Iterator;
 use option::{Some, None};
 use rt::io::Writer;
 use str::OwnedStr;
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index bcd658ece66..fab8299f7a7 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -19,8 +19,8 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, FromIterator, Extendable};
-use iterator::{FilterMap, Chain, Repeat, Zip};
+use iter::{Iterator, FromIterator, Extendable};
+use iter::{FilterMap, Chain, Repeat, Zip};
 use num;
 use option::{None, Option, Some};
 use rand::RngUtil;
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index ee948446614..9919cca6729 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -52,7 +52,7 @@ use clone::Clone;
 use c_str::ToCStr;
 use container::Container;
 use int;
-use iterator::Iterator;
+use iter::Iterator;
 use libc::consts::os::posix88::*;
 use libc::{c_int, c_void, size_t};
 use libc;
diff --git a/src/libstd/iterator.rs b/src/libstd/iter.rs
index 77637b6998e..5ca827350d0 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iter.rs
@@ -363,7 +363,7 @@ pub trait Iterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::Counter;
+    /// use std::iter::count;
     ///
     /// for i in count(0, 10) {
     ///     printfln!("%d", i);
@@ -754,7 +754,7 @@ pub trait MultiplicativeIterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::Counter;
+    /// use std::iter::count;
     ///
     /// fn factorial(n: uint) -> uint {
     ///     count(1u, 1).take_while(|&i| i <= n).product()
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index dd66630187d..b72046cce72 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -45,8 +45,8 @@ use clone::Clone;
 use cmp::{Eq,Ord};
 use util;
 use num::Zero;
-use iterator;
-use iterator::{Iterator, DoubleEndedIterator, ExactSize};
+use iter;
+use iter::{Iterator, DoubleEndedIterator, ExactSize};
 use str::{StrSlice, OwnedStr};
 use to_str::ToStr;
 use clone::DeepClone;
@@ -60,19 +60,19 @@ pub enum Option<T> {
 
 impl<T: Eq + Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
-        iterator::order::lt(self.iter(), other.iter())
+        iter::order::lt(self.iter(), other.iter())
     }
 
     fn le(&self, other: &Option<T>) -> bool {
-        iterator::order::le(self.iter(), other.iter())
+        iter::order::le(self.iter(), other.iter())
     }
 
     fn ge(&self, other: &Option<T>) -> bool {
-        iterator::order::ge(self.iter(), other.iter())
+        iter::order::ge(self.iter(), other.iter())
     }
 
     fn gt(&self, other: &Option<T>) -> bool {
-        iterator::order::gt(self.iter(), other.iter())
+        iter::order::gt(self.iter(), other.iter())
     }
 }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index ffd99fc9f75..ab1210aabad 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -32,7 +32,7 @@ use c_str::ToCStr;
 use clone::Clone;
 use container::Container;
 use io;
-use iterator::range;
+use iter::range;
 use libc;
 use libc::{c_char, c_void, c_int, size_t};
 use libc::FILE;
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
index 58668775136..336284963a2 100644
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@@ -21,7 +21,7 @@ use c_str;
 use clone::Clone;
 use cmp::Eq;
 use container::Container;
-use iterator::{Iterator, range};
+use iter::{Iterator, range};
 use libc;
 use num;
 use option::{None, Option, Some};
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 9cdf7af091f..818b0562955 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -40,7 +40,7 @@ pub use result::{Result, Ok, Err};
 
 // Reexported functions
 pub use io::{print, println};
-pub use iterator::range;
+pub use iter::range;
 pub use from_str::from_str;
 
 // Reexported types and traits
@@ -51,9 +51,9 @@ pub use char::Char;
 pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 pub use hash::Hash;
 pub use num::Times;
-pub use iterator::{FromIterator, Extendable};
-pub use iterator::{Iterator, DoubleEndedIterator, RandomAccessIterator, ClonableIterator};
-pub use iterator::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
+pub use iter::{FromIterator, Extendable};
+pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, ClonableIterator};
+pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};
 pub use num::{Orderable, Signed, Unsigned, Round};
 pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 38d8a244895..fafb1511973 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -14,7 +14,7 @@ use cast;
 use clone::Clone;
 #[cfg(not(test))]
 use cmp::Equiv;
-use iterator::{range, Iterator};
+use iter::{range, Iterator};
 use option::{Option, Some, None};
 #[cfg(stage0)]
 use sys;
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 58c75d3b408..813901207bb 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -48,7 +48,7 @@ use clone::Clone;
 use cmp;
 use container::Container;
 use int;
-use iterator::{Iterator, range};
+use iter::{Iterator, range};
 use local_data;
 use num;
 use prelude::*;
@@ -957,7 +957,7 @@ pub fn random<T: Rand>() -> T {
 
 #[cfg(test)]
 mod test {
-    use iterator::{Iterator, range};
+    use iter::{Iterator, range};
     use option::{Option, Some};
     use super::*;
 
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index d3a648f8d53..e3a6e4b5f85 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -20,7 +20,7 @@ use cast::transmute;
 use char;
 use container::Container;
 use rt::io;
-use iterator::Iterator;
+use iter::Iterator;
 use libc::c_void;
 use option::{Some, None};
 use ptr;
diff --git a/src/libstd/repr_stage0.rs b/src/libstd/repr_stage0.rs
index 4e580d91d0c..cbce2005141 100644
--- a/src/libstd/repr_stage0.rs
+++ b/src/libstd/repr_stage0.rs
@@ -20,7 +20,7 @@ use cast::transmute;
 use char;
 use container::Container;
 use io::{Writer, WriterUtil};
-use iterator::Iterator;
+use iter::Iterator;
 use libc::c_void;
 use option::{Some, None};
 use ptr;
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index c7613ed3c2f..793086dca78 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -15,7 +15,7 @@
 use clone::Clone;
 use cmp::Eq;
 use either;
-use iterator::Iterator;
+use iter::Iterator;
 use option::{None, Option, Some, OptionIterator};
 use vec;
 use vec::OwnedVector;
@@ -335,7 +335,7 @@ mod tests {
     use super::*;
 
     use either;
-    use iterator::range;
+    use iter::range;
     use str::OwnedStr;
     use vec::ImmutableVector;
 
diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs
index e5075f8818a..afa8d3261fc 100644
--- a/src/libstd/rt/args.rs
+++ b/src/libstd/rt/args.rs
@@ -55,7 +55,7 @@ pub fn clone() -> Option<~[~str]> {
 mod imp {
     use libc;
     use option::{Option, Some, None};
-    use iterator::Iterator;
+    use iter::Iterator;
     use str;
     use unstable::finally::Finally;
     use util;
diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs
index 15ac6544dee..e221f0ee94d 100644
--- a/src/libstd/rt/io/extensions.rs
+++ b/src/libstd/rt/io/extensions.rs
@@ -15,7 +15,7 @@
 
 use uint;
 use int;
-use iterator::Iterator;
+use iter::Iterator;
 use vec;
 use rt::io::{Reader, Writer, Decorator};
 use rt::io::{read_error, standard_error, EndOfFile, DEFAULT_BUF_SIZE};
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 14ff1fd5804..c9c3c4ec6da 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -59,7 +59,7 @@ Several modules in `core` are clients of `rt`:
 use cell::Cell;
 use clone::Clone;
 use container::Container;
-use iterator::Iterator;
+use iter::Iterator;
 use option::{Option, None, Some};
 use ptr::RawPtr;
 use rt::local::Local;
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 6aa66a6ab6b..bcf9ae4a2a8 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -27,7 +27,7 @@ use rt::rtio::{RemoteCallback, PausibleIdleCallback};
 use borrow::{to_uint};
 use cell::Cell;
 use rand::{XorShiftRng, RngUtil};
-use iterator::{range};
+use iter::range;
 use vec::{OwnedVector};
 
 /// A scheduler is responsible for coordinating the execution of Tasks
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 2c293af1eaf..f35fe1a1d04 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -14,7 +14,7 @@ use option::{Some, None};
 use cell::Cell;
 use clone::Clone;
 use container::Container;
-use iterator::{Iterator, range};
+use iter::{Iterator, range};
 use super::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
 use vec::{OwnedVector, MutableVector, ImmutableVector};
 use rt::sched::Scheduler;
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index c9b12e47f92..65910e5ad08 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -44,7 +44,7 @@ use task;
 #[cfg(test)] use rt::test::{spawntask,
                             next_test_ip4,
                             run_in_newsched_task};
-#[cfg(test)] use iterator::{Iterator, range};
+#[cfg(test)] use iter::{Iterator, range};
 
 // XXX we should not be calling uvll functions in here.
 
diff --git a/src/libstd/select.rs b/src/libstd/select.rs
index 9f4fd8db788..94db609e9c7 100644
--- a/src/libstd/select.rs
+++ b/src/libstd/select.rs
@@ -11,7 +11,7 @@
 use cell::Cell;
 use comm;
 use container::Container;
-use iterator::{Iterator, DoubleEndedIterator};
+use iter::{Iterator, DoubleEndedIterator};
 use option::*;
 // use either::{Either, Left, Right};
 // use rt::kill::BlockedTask;
@@ -134,7 +134,7 @@ mod test {
     use comm::GenericChan;
     use task;
     use cell::Cell;
-    use iterator::{Iterator, range};
+    use iter::{Iterator, range};
 
     #[test] #[should_fail]
     fn select_doesnt_get_trolled() {
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index ce0202ded7e..65fd24b7219 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -140,7 +140,7 @@ pub mod borrow;
 pub mod from_str;
 #[path = "num/num.rs"]
 pub mod num;
-pub mod iterator;
+pub mod iter;
 pub mod to_str;
 pub mod to_bytes;
 pub mod clone;
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 9d718c30edb..0f125280c2d 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -23,9 +23,9 @@ use char::Char;
 use clone::{Clone, DeepClone};
 use container::{Container, Mutable};
 use num::Times;
-use iterator::{Iterator, FromIterator, Extendable};
-use iterator::{Filter, AdditiveIterator, Map};
-use iterator::{Invert, DoubleEndedIterator, ExactSize};
+use iter::{Iterator, FromIterator, Extendable};
+use iter::{Filter, AdditiveIterator, Map};
+use iter::{Invert, DoubleEndedIterator, ExactSize};
 use libc;
 use num::{Saturating};
 use option::{None, Option, Some};
@@ -592,7 +592,7 @@ impl<'self> Iterator<&'self str> for StrSplitIterator<'self> {
 
 // Helper functions used for Unicode normalization
 fn canonical_sort(comb: &mut [(char, u8)]) {
-    use iterator::range;
+    use iter::range;
     use tuple::CopyableTuple;
 
     let len = comb.len();
@@ -3325,7 +3325,7 @@ mod tests {
 
     #[test]
     fn test_iterator() {
-        use iterator::*;
+        use iter::*;
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 
@@ -3341,7 +3341,7 @@ mod tests {
 
     #[test]
     fn test_rev_iterator() {
-        use iterator::*;
+        use iter::*;
         let s = ~"ศไทย中华Việt Nam";
         let v = ~['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
 
@@ -3397,7 +3397,7 @@ mod tests {
 
     #[test]
     fn test_char_offset_iterator() {
-        use iterator::*;
+        use iter::*;
         let s = "ศไทย中华Việt Nam";
         let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
         let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
@@ -3415,7 +3415,7 @@ mod tests {
 
     #[test]
     fn test_char_offset_rev_iterator() {
-        use iterator::*;
+        use iter::*;
         let s = "ศไทย中华Việt Nam";
         let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
         let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
diff --git a/src/libstd/str/ascii.rs b/src/libstd/str/ascii.rs
index 4ed969f628e..2dd93feef05 100644
--- a/src/libstd/str/ascii.rs
+++ b/src/libstd/str/ascii.rs
@@ -17,7 +17,7 @@ use str::OwnedStr;
 use container::Container;
 use cast;
 use ptr;
-use iterator::Iterator;
+use iter::Iterator;
 use vec::{CopyableVector, ImmutableVector};
 use to_bytes::IterBytes;
 use option::{Some, None};
diff --git a/src/libstd/to_bytes.rs b/src/libstd/to_bytes.rs
index e3615b7b7db..855cdfcb851 100644
--- a/src/libstd/to_bytes.rs
+++ b/src/libstd/to_bytes.rs
@@ -18,7 +18,7 @@ use cast;
 use container::Container;
 use io;
 use io::Writer;
-use iterator::Iterator;
+use iter::Iterator;
 use option::{None, Option, Some};
 use str::{Str, StrSlice};
 use vec::{Vector, ImmutableVector};
diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs
index a8c450a0516..ff701267189 100644
--- a/src/libstd/to_str.rs
+++ b/src/libstd/to_str.rs
@@ -19,7 +19,7 @@ use str::OwnedStr;
 use hashmap::HashMap;
 use hashmap::HashSet;
 use hash::Hash;
-use iterator::Iterator;
+use iter::Iterator;
 use cmp::Eq;
 use vec::ImmutableVector;
 
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index f5c7b719c4f..32797216376 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -11,7 +11,6 @@
 //! An ordered map and set for integer keys implemented as a radix trie
 
 use prelude::*;
-use iterator::{FromIterator, Extendable};
 use uint;
 use util::{swap, replace};
 use vec;
diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs
index 1b1e4be4ee1..d7f84a6abfb 100644
--- a/src/libstd/unicode.rs
+++ b/src/libstd/unicode.rs
@@ -3628,7 +3628,7 @@ pub mod decompose {
     }
 
     fn d(c: char, i: &fn(char), k: bool) {
-        use iterator::Iterator;
+        use iter::Iterator;
         if c <= '\x7f' { i(c); return; }
 
         match bsearch_table(c, canonical_table) {
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 4cc5c4f14ff..138a1cab5a0 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -63,7 +63,7 @@ use clone::{Clone, DeepClone};
 use container::{Container, Mutable};
 use cmp::{Eq, TotalOrd, Ordering, Less, Equal, Greater};
 use cmp;
-use iterator::*;
+use iter::*;
 use libc::c_void;
 use num::{Integer, Zero, CheckedAdd, Saturating};
 use option::{None, Option, Some};
@@ -592,7 +592,7 @@ pub mod traits {
 
     use clone::Clone;
     use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Equiv};
-    use iterator::order;
+    use iter::order;
     use ops::Add;
 
     impl<'self,T:Eq> Eq for &'self [T] {
@@ -3241,7 +3241,7 @@ mod tests {
 
     #[test]
     fn test_iterator() {
-        use iterator::*;
+        use iter::*;
         let xs = [1, 2, 5, 10, 11];
         let mut it = xs.iter();
         assert_eq!(it.size_hint(), (5, Some(5)));
@@ -3260,7 +3260,7 @@ mod tests {
 
     #[test]
     fn test_random_access_iterator() {
-        use iterator::*;
+        use iter::*;
         let xs = [1, 2, 5, 10, 11];
         let mut it = xs.iter();
 
@@ -3299,7 +3299,7 @@ mod tests {
 
     #[test]
     fn test_iter_size_hints() {
-        use iterator::*;
+        use iter::*;
         let mut xs = [1, 2, 5, 10, 11];
         assert_eq!(xs.iter().size_hint(), (5, Some(5)));
         assert_eq!(xs.rev_iter().size_hint(), (5, Some(5)));
@@ -3320,7 +3320,7 @@ mod tests {
 
     #[test]
     fn test_mut_iterator() {
-        use iterator::*;
+        use iter::*;
         let mut xs = [1, 2, 3, 4, 5];
         for x in xs.mut_iter() {
             *x += 1;
@@ -3330,7 +3330,7 @@ mod tests {
 
     #[test]
     fn test_rev_iterator() {
-        use iterator::*;
+        use iter::*;
 
         let xs = [1, 2, 5, 10, 11];
         let ys = [11, 10, 5, 2, 1];
@@ -3344,7 +3344,7 @@ mod tests {
 
     #[test]
     fn test_mut_rev_iterator() {
-        use iterator::*;
+        use iter::*;
         let mut xs = [1u, 2, 3, 4, 5];
         for (i,x) in xs.mut_rev_iter().enumerate() {
             *x += i;
@@ -3354,14 +3354,14 @@ mod tests {
 
     #[test]
     fn test_move_iterator() {
-        use iterator::*;
+        use iter::*;
         let xs = ~[1u,2,3,4,5];
         assert_eq!(xs.move_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
     }
 
     #[test]
     fn test_move_rev_iterator() {
-        use iterator::*;
+        use iter::*;
         let xs = ~[1u,2,3,4,5];
         assert_eq!(xs.move_rev_iter().fold(0, |a: uint, b: uint| 10*a + b), 54321);
     }
diff --git a/src/test/auxiliary/nested_item.rs b/src/test/auxiliary/nested_item.rs
index e9dde0d14a3..c2f38134d1e 100644
--- a/src/test/auxiliary/nested_item.rs
+++ b/src/test/auxiliary/nested_item.rs
@@ -26,7 +26,7 @@ impl<T> Foo {
 
 // issue 8134
 pub struct Parser<T>;
-impl<T: std::iterator::Iterator<char>> Parser<T> {
+impl<T: std::iter::Iterator<char>> Parser<T> {
     fn in_doctype(&mut self) {
         static DOCTYPEPattern: [char, ..6] = ['O', 'C', 'T', 'Y', 'P', 'E'];
     }
diff --git a/src/test/run-pass/unfold-cross-crate.rs b/src/test/run-pass/unfold-cross-crate.rs
index 64cf3077c53..42e680d95e1 100644
--- a/src/test/run-pass/unfold-cross-crate.rs
+++ b/src/test/run-pass/unfold-cross-crate.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::iterator::*;
+use std::iter::*;
 
 // Unfold had a bug with 'self that mean it didn't work
 // cross-crate