core: Make range follow the for loop protocol

Author: brson

src/compiletest/runtest.rs

@@ -277,7 +277,7 @@ fn check_expected_errors(expected_errors: [errors::expected_error],
         }
     }
 
-    uint::range(0u, vec::len(found_flags)) {|i|
+    for uint::range(0u, vec::len(found_flags)) {|i|
         if !found_flags[i] {
             let ee = expected_errors[i];
             fatal_procres(#fmt["expected %s on line %u not found: %s",

src/libcore/int-template.rs

@@ -36,9 +36,12 @@ pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
 pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
-fn range(lo: T, hi: T, it: fn(T)) {
+fn range(lo: T, hi: T, it: fn(T) -> bool) {
     let mut i = lo;
-    while i < hi { it(i); i += 1 as T; }
+    while i < hi {
+        if !it(i) { break }
+        i += 1 as T;
+    }
 }
 
 #[doc = "Computes the bitwise complement"]

src/libcore/priv.rs

@@ -127,12 +127,12 @@ fn test_from_global_chan2() unsafe {
 
         // Spawn a bunch of tasks that all want to compete to
         // create the global channel
-        uint::range(0u, 10u) {|i|
+        for uint::range(0u, 10u) {|i|
             task::spawn() {||
                 let ch = chan_from_global_ptr(
                     globchanp, task::builder) {|po|
 
-                    uint::range(0u, 10u) {|_j|
+                    for uint::range(0u, 10u) {|_j|
                         let ch = comm::recv(po);
                         comm::send(ch, {i});
                     }
@@ -147,7 +147,7 @@ fn test_from_global_chan2() unsafe {
         }
         // There should be only one winner
         let mut winners = 0u;
-        uint::range(0u, 10u) {|_i|
+        for uint::range(0u, 10u) {|_i|
             let res = comm::recv(resultpo);
             if res { winners += 1u };
         }

src/libcore/rand.rs

@@ -202,7 +202,7 @@ impl extensions for rng {
     fn weighted_vec<T:copy>(v: [weighted<T>]) -> [T] {
         let mut r = [];
         for v.each {|item|
-            uint::range(0u, item.weight) {|_i|
+            for uint::range(0u, item.weight) {|_i|
                 r += [item.item];
             }
         }

src/libcore/uint-template.rs

@@ -35,9 +35,12 @@ pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
 pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
-fn range(lo: T, hi: T, it: fn(T)) {
+fn range(lo: T, hi: T, it: fn(T) -> bool) {
     let mut i = lo;
-    while i < hi { it(i); i += 1 as T; }
+    while i < hi {
+        if !it(i) { break }
+        i += 1 as T;
+    }
 }
 
 #[doc = "Computes the bitwise complement"]

src/libcore/vec.rs

@@ -892,7 +892,7 @@ Both vectors must have the same length
 #[inline]
 fn iter2<U, T>(v1: [const U], v2: [const T], f: fn(U, T)) {
     assert len(v1) == len(v2);
-    uint::range(0u, len(v1)) {|i|
+    for uint::range(0u, len(v1)) {|i|
         f(v1[i], v2[i])
     }
 }

src/librustsyntax/codemap.rs

@@ -183,7 +183,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     let mut lines = [];
-    uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
+    for uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
     ret @{file: lo.file, lines: lines};
 }
 

src/librustsyntax/ext/qquote.rs

@@ -193,7 +193,7 @@ fn finish<T: qq_helper>
     let qcx = gather_anti_quotes(sp.lo, node);
     let cx = qcx;
 
-    uint::range(1u, cx.gather.len()) {|i|
+    for uint::range(1u, cx.gather.len()) {|i|
         assert cx.gather[i-1u].lo < cx.gather[i].lo;
         // ^^ check that the vector is sorted
         assert cx.gather[i-1u].hi <= cx.gather[i].lo;

src/libstd/bitv.rs

@@ -46,7 +46,7 @@ fn process(v0: bitv, v1: bitv, op: fn(uint, uint) -> uint) -> bool {
     assert (vec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
     let mut changed = false;
-    uint::range(0u, len) {|i|
+    for uint::range(0u, len) {|i|
         let w0 = v0.storage[i];
         let w1 = v1.storage[i];
         let w = op(w0, w1);
@@ -90,7 +90,7 @@ fn assign(v0: bitv, v1: bitv) -> bool {
 fn clone(v: bitv) -> bitv {
     let storage = vec::to_mut(vec::from_elem(v.nbits / uint_bits + 1u, 0u));
     let len = vec::len(v.storage);
-    uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
+    for uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
 }
 
@@ -121,17 +121,17 @@ fn equal(v0: bitv, v1: bitv) -> bool {
 
 #[doc = "Set all bits to 0"]
 fn clear(v: bitv) {
-    uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
+    for uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
 }
 
 #[doc = "Set all bits to 1"]
 fn set_all(v: bitv) {
-    uint::range(0u, v.nbits) {|i| set(v, i, true); };
+    for uint::range(0u, v.nbits) {|i| set(v, i, true); };
 }
 
 #[doc = "Invert all bits"]
 fn invert(v: bitv) {
-    uint::range(0u, vec::len(v.storage)) {|i|
+    for uint::range(0u, vec::len(v.storage)) {|i|
         v.storage[i] = !v.storage[i];
     };
 }

src/libstd/rope.rs

@@ -158,13 +158,13 @@ fn concat(v: [rope]) -> rope {
     let mut len = vec::len(v);
     if len == 0u { ret node::empty; }
     let ropes = vec::to_mut(vec::from_elem(len, v[0]));
-    uint::range(1u, len) {|i|
+    for uint::range(1u, len) {|i|
        ropes[i] = v[i];
     }
 
     //Merge progresively
     while len > 1u {
-        uint::range(0u, len/2u) {|i|
+        for uint::range(0u, len/2u) {|i|
             ropes[i] = append_rope(ropes[2u*i], ropes[2u*i+1u]);
         }
         if len%2u != 0u {
@@ -1352,19 +1352,19 @@ mod tests {
     fn char_at1() {
         //Generate a large rope
         let mut r = of_str(@ "123456789");
-        uint::range(0u, 10u){|_i|
+        for uint::range(0u, 10u){|_i|
             r = append_rope(r, r);
         }
 
         //Copy it in the slowest possible way
         let mut r2 = empty();
-        uint::range(0u, char_len(r)){|i|
+        for uint::range(0u, char_len(r)){|i|
             r2 = append_char(r2, char_at(r, i));
         }
         assert eq(r, r2);
 
         let mut r3 = empty();
-        uint::range(0u, char_len(r)){|i|
+        for uint::range(0u, char_len(r)){|i|
             r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u));
         }
         assert eq(r, r3);
@@ -1385,7 +1385,7 @@ mod tests {
         //Generate a reasonable rope
         let chunk = of_str(@ "123456789");
         let mut r = empty();
-        uint::range(0u, 10u){|_i|
+        for uint::range(0u, 10u){|_i|
             r = append_rope(r, chunk);
         }