---

yaml
---
r: 144909
b: refs/heads/try2
c: bb30f04
h: refs/heads/master
i:
  144907: 35eef4a
v: v3

Author: catamorphism

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: af259a651d52e7243c74a833b2b39a61890e89fe
+refs/heads/try2: bb30f047f6dbb5c8a73d105b25c2dc23d814b9ba
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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::iter::range_inclusive(0, 5) { // needs explicit import
+for i in std::iterator::range_inclusive(0, 5) { // needs explicit import
   printf!("%d ", i) // prints "0 1 2 3 4 5"
 }
 ~~~

branches/try2/mk/rt.mk

@@ -176,7 +176,7 @@ LIBUV_NO_LOAD = run-benchmarks.target.mk run-tests.target.mk \
 
 export PYTHONPATH := $(PYTHONPATH):$$(S)src/gyp/pylib
 
-$$(LIBUV_MAKEFILE_$(1)_$(2)): $$(LIBUV_DEPS)
+$$(LIBUV_MAKEFILE_$(1)_$(2)):
 	(cd $(S)src/libuv/ && \
 	 $$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
 	   -Goutput_dir=$$(@D) --generator-output $$(@D))

branches/try2/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 iter::Iterator;\n");
+    f.write("        use iterator::Iterator;\n");
 
     f.write("        if c <= '\\x7f' { i(c); return; }\n")
 

branches/try2/src/libextra/bitv.rs

@@ -12,8 +12,8 @@
 
 
 use std::cmp;
-use std::iter::RandomAccessIterator;
-use std::iter::{Invert, Enumerate, Repeat, Map, Zip};
+use std::iterator::RandomAccessIterator;
+use std::iterator::{Invert, Enumerate, Repeat, Map, Zip};
 use std::num;
 use std::ops;
 use std::uint;

branches/try2/src/libextra/dlist.rs

@@ -25,8 +25,8 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iter::Invert;
-use std::iter;
+use std::iterator::{FromIterator, Extendable, Invert};
+use std::iterator;
 
 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() &&
-            iter::order::eq(self.iter(), other.iter())
+            iterator::order::eq(self.iter(), other.iter())
     }
 
     fn ne(&self, other: &DList<A>) -> bool {
         self.len() != other.len() ||
-            iter::order::ne(self.iter(), other.iter())
+            iterator::order::ne(self.iter(), other.iter())
     }
 }
 
 impl<A: Eq + Ord> Ord for DList<A> {
     fn lt(&self, other: &DList<A>) -> bool {
-        iter::order::lt(self.iter(), other.iter())
+        iterator::order::lt(self.iter(), other.iter())
     }
     fn le(&self, other: &DList<A>) -> bool {
-        iter::order::le(self.iter(), other.iter())
+        iterator::order::le(self.iter(), other.iter())
     }
     fn gt(&self, other: &DList<A>) -> bool {
-        iter::order::gt(self.iter(), other.iter())
+        iterator::order::gt(self.iter(), other.iter())
     }
     fn ge(&self, other: &DList<A>) -> bool {
-        iter::order::ge(self.iter(), other.iter())
+        iterator::order::ge(self.iter(), other.iter())
     }
 }
 

branches/try2/src/libextra/enum_set.rs

@@ -8,6 +8,8 @@
 // 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> {

branches/try2/src/libextra/json.rs

@@ -18,6 +18,7 @@
 
 use std::char;
 use std::cast::transmute;
+use std::iterator;
 use std::float;
 use std::hashmap::HashMap;
 use std::io::WriterUtil;
@@ -488,7 +489,7 @@ pub struct Parser<T> {
 }
 
 /// Decode a json value from an Iterator<char>
-pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
+pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
     let mut p = Parser {
         rdr: rdr,
         ch: '\x00',
@@ -499,7 +500,7 @@ pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
     p
 }
 
-impl<T: Iterator<char>> Parser<T> {
+impl<T: iterator::Iterator<char>> Parser<T> {
     pub fn parse(&mut self) -> Result<Json, Error> {
         match self.parse_value() {
           Ok(value) => {
@@ -517,7 +518,7 @@ impl<T: Iterator<char>> Parser<T> {
     }
 }
 
-impl<T : Iterator<char>> Parser<T> {
+impl<T : iterator::Iterator<char>> Parser<T> {
     // FIXME: #8971: unsound
     fn eof(&self) -> bool { self.ch == unsafe { transmute(-1u32) } }
 

branches/try2/src/libextra/num/bigint.rs

@@ -153,43 +153,6 @@ impl Orderable for BigUint {
     }
 }
 
-impl BitAnd<BigUint, BigUint> for BigUint {
-    fn bitand(&self, other: &BigUint) -> BigUint {
-        let new_len = num::min(self.data.len(), other.data.len());
-        let anded = do vec::from_fn(new_len) |i| {
-            // i will never be less than the size of either data vector
-            let ai = self.data[i];
-            let bi = other.data[i];
-            ai & bi
-        };
-        return BigUint::new(anded);
-    }
-}
-
-impl BitOr<BigUint, BigUint> for BigUint {
-    fn bitor(&self, other: &BigUint) -> BigUint {
-        let new_len = num::max(self.data.len(), other.data.len());
-        let ored = do vec::from_fn(new_len) |i| {
-            let ai = if i < self.data.len()  { self.data[i]  } else { 0 };
-            let bi = if i < other.data.len() { other.data[i] } else { 0 };
-            ai | bi
-        };
-        return BigUint::new(ored);
-    }
-}
-
-impl BitXor<BigUint, BigUint> for BigUint {
-    fn bitxor(&self, other: &BigUint) -> BigUint {
-        let new_len = num::max(self.data.len(), other.data.len());
-        let xored = do vec::from_fn(new_len) |i| {
-            let ai = if i < self.data.len()  { self.data[i]  } else { 0 };
-            let bi = if i < other.data.len() { other.data[i] } else { 0 };
-            ai ^ bi
-        };
-        return BigUint::new(xored);
-    }
-}
-
 impl Shl<uint, BigUint> for BigUint {
     #[inline]
     fn shl(&self, rhs: &uint) -> BigUint {
@@ -1203,48 +1166,6 @@ mod biguint_tests {
         }
     }
 
-    #[test]
-    fn test_bitand() {
-        fn check(left: ~[BigDigit],
-                 right: ~[BigDigit],
-                 expected: ~[BigDigit]) {
-            assert_eq!(BigUint::new(left) & BigUint::new(right),
-                       BigUint::new(expected));
-        }
-        check(~[], ~[], ~[]);
-        check(~[268, 482, 17],
-              ~[964, 54],
-              ~[260, 34]);
-    }
-
-    #[test]
-    fn test_bitor() {
-        fn check(left: ~[BigDigit],
-                 right: ~[BigDigit],
-                 expected: ~[BigDigit]) {
-            assert_eq!(BigUint::new(left) | BigUint::new(right),
-                       BigUint::new(expected));
-        }
-        check(~[], ~[], ~[]);
-        check(~[268, 482, 17],
-              ~[964, 54],
-              ~[972, 502, 17]);
-    }
-
-    #[test]
-    fn test_bitxor() {
-        fn check(left: ~[BigDigit],
-                 right: ~[BigDigit],
-                 expected: ~[BigDigit]) {
-            assert_eq!(BigUint::new(left) ^ BigUint::new(right),
-                       BigUint::new(expected));
-        }
-        check(~[], ~[], ~[]);
-        check(~[268, 482, 17],
-              ~[964, 54],
-              ~[712, 468, 17]);
-    }
-
     #[test]
     fn test_shl() {
         fn check(s: &str, shift: uint, ans: &str) {
@@ -2090,13 +2011,13 @@ mod bigint_tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use std::{iter, util};
+    use std::{iterator, util};
     use std::num::{Zero, One};
     use extra::test::BenchHarness;
 
     fn factorial(n: uint) -> BigUint {
         let mut f: BigUint = One::one();
-        for i in iter::range_inclusive(1, n) {
+        for i in iterator::range_inclusive(1, n) {
             f = f * BigUint::from_uint(i);
         }
         f

branches/try2/src/libextra/priority_queue.rs

@@ -16,6 +16,7 @@ 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)]

branches/try2/src/libextra/ringbuf.rs

@@ -15,7 +15,7 @@
 
 use std::num;
 use std::vec;
-use std::iter::{Invert, RandomAccessIterator};
+use std::iterator::{FromIterator, Invert, RandomAccessIterator, Extendable};
 
 use container::Deque;
 
@@ -694,13 +694,13 @@ mod tests {
 
     #[test]
     fn test_from_iterator() {
-        use std::iter;
+        use std::iterator;
         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 = iter::count(0u, 2).take(256);
+        let mut seq = iterator::count(0u, 2).take(256);
         let deq: RingBuf<uint> = seq.collect();
         for (i, &x) in deq.iter().enumerate() {
             assert_eq!(2*i, x);

branches/try2/src/libextra/smallintmap.rs

@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use std::iter::{Enumerate, FilterMap, Invert};
+use std::iterator::{Iterator, Enumerate, FilterMap, Invert};
 use std::util::replace;
 use std::vec::{VecIterator, VecMutIterator};
 use std::vec;

branches/try2/src/libextra/treemap.rs

@@ -14,7 +14,7 @@
 
 
 use std::util::{swap, replace};
-use std::iter::{Peekable};
+use std::iterator::{FromIterator, Extendable, Peekable};
 use std::cmp::Ordering;
 
 // This is implemented as an AA tree, which is a simplified variation of