---

yaml
---
r: 5897
b: refs/heads/master
c: 6bcb4a4
h: refs/heads/master
i:
  5895: 974fca1
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4ebbbe597e44dbed0da3027fbf4e564390e0daeb
+refs/heads/master: 6bcb4a426c80a3ee19e7b32f25942a54c43e4387

trunk/src/comp/back/rpath.rs

@@ -137,9 +137,7 @@ fn get_relative_to(abs1: fs::path, abs2: fs::path) -> fs::path {
 
     let path = [];
 
-    for each _ in uint::range(start_idx, len1 - 1u) {
-        path += [".."];
-    }
+    uint::range(start_idx, len1 - 1u) {|_i| path += [".."]; };
 
     path += vec::slice(split2, start_idx, len2 - 1u);
 

trunk/src/comp/metadata/decoder.rs

@@ -41,12 +41,12 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
 
     let result: [ebml::doc] = [];
     let belt = tag_index_buckets_bucket_elt;
-    for each elt: ebml::doc in ebml::tagged_docs(bucket, belt) {
+    ebml::tagged_docs(bucket, belt) {|elt|
         let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
         if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
             result += [ebml::doc_at(d.data, pos)];
         }
-    }
+    };
     ret result;
 }
 
@@ -111,7 +111,7 @@ fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
 fn item_ty_param_kinds(item: ebml::doc) -> [ast::kind] {
     let ks: [ast::kind] = [];
     let tp = tag_items_data_item_ty_param_kinds;
-    for each p: ebml::doc in ebml::tagged_docs(item, tp) {
+    ebml::tagged_docs(item, tp) {|p|
         let dat: [u8] = ebml::doc_data(p);
         let vi = ebml::vint_at(dat, 0u);
         let i = 0u;
@@ -125,18 +125,18 @@ fn item_ty_param_kinds(item: ebml::doc) -> [ast::kind] {
             ks += [k];
             i += 1u;
         }
-    }
+    };
     ret ks;
 }
 
 fn tag_variant_ids(item: ebml::doc, this_cnum: ast::crate_num) ->
    [ast::def_id] {
     let ids: [ast::def_id] = [];
     let v = tag_items_data_item_variant;
-    for each p: ebml::doc in ebml::tagged_docs(item, v) {
+    ebml::tagged_docs(item, v) {|p|
         let ext = parse_def_id(ebml::doc_data(p));
         ids += [{crate: this_cnum, node: ext.node}];
-    }
+    };
     ret ids;
 }
 
@@ -300,38 +300,34 @@ fn item_family_to_str(fam: u8) -> str {
 
 fn get_meta_items(md: ebml::doc) -> [@ast::meta_item] {
     let items: [@ast::meta_item] = [];
-    for each meta_item_doc: ebml::doc in
-             ebml::tagged_docs(md, tag_meta_item_word) {
+    ebml::tagged_docs(md, tag_meta_item_word) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         items += [attr::mk_word_item(n)];
-    }
-    for each meta_item_doc: ebml::doc in
-             ebml::tagged_docs(md, tag_meta_item_name_value) {
+    };
+    ebml::tagged_docs(md, tag_meta_item_name_value) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
         let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         let v = str::unsafe_from_bytes(ebml::doc_data(vd));
         // FIXME (#611): Should be able to decode meta_name_value variants,
         // but currently they can't be encoded
         items += [attr::mk_name_value_item_str(n, v)];
-    }
-    for each meta_item_doc: ebml::doc in
-             ebml::tagged_docs(md, tag_meta_item_list) {
+    };
+    ebml::tagged_docs(md, tag_meta_item_list) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::unsafe_from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items += [attr::mk_list_item(n, subitems)];
-    }
+    };
     ret items;
 }
 
 fn get_attributes(md: ebml::doc) -> [ast::attribute] {
     let attrs: [ast::attribute] = [];
     alt ebml::maybe_get_doc(md, tag_attributes) {
       option::some(attrs_d) {
-        for each attr_doc: ebml::doc in
-                 ebml::tagged_docs(attrs_d, tag_attribute) {
+        ebml::tagged_docs(attrs_d, tag_attribute) {|attr_doc|
             let meta_items = get_meta_items(attr_doc);
             // Currently it's only possible to have a single meta item on
             // an attribute
@@ -340,7 +336,7 @@ fn get_attributes(md: ebml::doc) -> [ast::attribute] {
             attrs +=
                 [{node: {style: ast::attr_outer, value: *meta_item},
                   span: ast_util::dummy_sp()}];
-        }
+        };
       }
       option::none. { }
     }
@@ -374,11 +370,11 @@ fn get_crate_deps(data: @[u8]) -> [crate_dep] {
     let cratedoc = ebml::new_doc(data);
     let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
     let crate_num = 1;
-    for each depdoc: ebml::doc in ebml::tagged_docs(depsdoc, tag_crate_dep) {
+    ebml::tagged_docs(depsdoc, tag_crate_dep) {|depdoc|
         let depname = str::unsafe_from_bytes(ebml::doc_data(depdoc));
         deps += [{cnum: crate_num, ident: depname}];
         crate_num += 1;
-    }
+    };
     ret deps;
 }
 
@@ -398,18 +394,17 @@ fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {
     let items = ebml::get_doc(md, tag_items);
     let index = ebml::get_doc(paths, tag_index);
     let bs = ebml::get_doc(index, tag_index_buckets);
-    for each bucket: ebml::doc in
-             ebml::tagged_docs(bs, tag_index_buckets_bucket) {
+    ebml::tagged_docs(bs, tag_index_buckets_bucket) {|bucket|
         let et = tag_index_buckets_bucket_elt;
-        for each elt: ebml::doc in ebml::tagged_docs(bucket, et) {
+        ebml::tagged_docs(bucket, et) {|elt|
             let data = read_path(elt);
             let def = ebml::doc_at(bytes, data.pos);
             let did_doc = ebml::get_doc(def, tag_def_id);
             let did = parse_def_id(ebml::doc_data(did_doc));
             out.write_str(#fmt["%s (%s)\n", data.path,
                                describe_def(items, did)]);
-        }
-    }
+        };
+    };
     out.write_str("\n");
 }
 

trunk/src/comp/metadata/encoder.rs

@@ -394,7 +394,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer) ->
 fn create_index<@T>(index: [entry<T>], hash_fn: fn(T) -> uint) ->
    [@[entry<T>]] {
     let buckets: [@mutable [entry<T>]] = [];
-    for each i: uint in uint::range(0u, 256u) { buckets += [@mutable []]; }
+    uint::range(0u, 256u) {|_i| buckets += [@mutable []]; };
     for elt: entry<T> in index {
         let h = hash_fn(elt.val);
         *buckets[h % 256u] += [elt];

trunk/src/comp/middle/trans.rs

@@ -5825,15 +5825,15 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str,
     if uses_retptr { call_args += [bcx.fcx.llretptr]; }
 
     let arg_n = 2u;
-    for each i: uint in uint::range(0u, num_ty_param) {
+    uint::range(0u, num_ty_param) {|_i|
         let llarg = llvm::LLVMGetParam(fcx.llfn, arg_n);
         fcx.lltydescs += [llarg];
         assert (llarg as int != 0);
         if cast_to_i32 {
             call_args += [vp2i(bcx, llarg)];
         } else { call_args += [llarg]; }
         arg_n += 1u;
-    }
+    };
     fn convert_arg_to_i32(cx: @block_ctxt, v: ValueRef, t: ty::t,
                           mode: ty::mode) -> ValueRef {
         if mode == ast::by_ref || mode == ast::by_val {

trunk/src/comp/syntax/codemap.rs

@@ -198,9 +198,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 lines = [];
-    for each i: uint in uint::range(lo.line - 1u, hi.line as uint) {
-        lines += [i];
-    }
+    uint::range(lo.line - 1u, hi.line as uint) {|i| lines += [i]; };
     ret @{name: lo.filename, lines: lines};
 }
 

trunk/src/lib/bitv.rs

@@ -40,12 +40,12 @@ fn process(op: block(uint, uint) -> uint, v0: t, v1: t) -> bool {
     assert (vec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
     let changed = false;
-    for each i: uint in uint::range(0u, len) {
+    uint::range(0u, len) {|i|
         let w0 = v0.storage[i];
         let w1 = v1.storage[i];
         let w = op(w0, w1);
         if w0 != w { changed = true; v0.storage[i] = w; }
-    }
+    };
     ret changed;
 }
 
@@ -67,7 +67,7 @@ fn assign(v0: t, v1: t) -> bool { let sub = right; ret process(sub, v0, v1); }
 fn clone(v: t) -> t {
     let storage = vec::init_elt_mut::<uint>(0u, v.nbits / uint_bits() + 1u);
     let len = vec::len(v.storage);
-    for each i: uint in uint::range(0u, len) { storage[i] = v.storage[i]; }
+    uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
 }
 
@@ -94,19 +94,17 @@ fn equal(v0: t, v1: t) -> bool {
 }
 
 fn clear(v: t) {
-    for each i: uint in uint::range(0u, vec::len(v.storage)) {
-        v.storage[i] = 0u;
-    }
+    uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
 }
 
 fn set_all(v: t) {
-    for each i: uint in uint::range(0u, v.nbits) { set(v, i, true); }
+    uint::range(0u, v.nbits) {|i| set(v, i, true); };
 }
 
 fn invert(v: t) {
-    for each i: uint in uint::range(0u, vec::len(v.storage)) {
+    uint::range(0u, vec::len(v.storage)) {|i|
         v.storage[i] = !v.storage[i];
-    }
+    };
 }
 
 

trunk/src/lib/ebml.rs

@@ -72,25 +72,24 @@ fn get_doc(d: doc, tg: uint) -> doc {
     }
 }
 
-iter docs(d: doc) -> {tag: uint, doc: doc} {
+fn docs(d: doc, it: block(uint, doc)) {
     let pos = d.start;
     while pos < d.end {
         let elt_tag = vint_at(*d.data, pos);
         let elt_size = vint_at(*d.data, elt_tag.next);
         pos = elt_size.next + elt_size.val;
-        put {tag: elt_tag.val,
-             doc: {data: d.data, start: elt_size.next, end: pos}};
+        it(elt_tag.val, {data: d.data, start: elt_size.next, end: pos});
     }
 }
 
-iter tagged_docs(d: doc, tg: uint) -> doc {
+fn tagged_docs(d: doc, tg: uint, it: block(doc)) {
     let pos = d.start;
     while pos < d.end {
         let elt_tag = vint_at(*d.data, pos);
         let elt_size = vint_at(*d.data, elt_tag.next);
         pos = elt_size.next + elt_size.val;
         if elt_tag.val == tg {
-            put {data: d.data, start: elt_size.next, end: pos};
+            it({data: d.data, start: elt_size.next, end: pos});
         }
     }
 }

trunk/src/lib/int.rs

@@ -43,9 +43,8 @@ fn hash(x: int) -> uint { ret x as uint; }
 
 fn eq_alias(x: int, y: int) -> bool { ret x == y; }
 
-iter range(lo: int, hi: int) -> int {
-    let lo_: int = lo;
-    while lo_ < hi { put lo_; lo_ += 1; }
+fn range(lo: int, hi: int, it: block(int)) {
+    while lo < hi { it(lo); lo += 1; }
 }
 
 fn parse_buf(buf: [u8], radix: uint) -> int {

trunk/src/lib/u8.rs

@@ -23,7 +23,10 @@ pure fn ge(x: u8, y: u8) -> bool { ret x >= y; }
 
 pure fn gt(x: u8, y: u8) -> bool { ret x > y; }
 
-iter range(lo: u8, hi: u8) -> u8 { while lo < hi { put lo; lo += 1u8; } }
+fn range(lo: u8, hi: u8, it: block(u8)) {
+    while lo < hi { it(lo); lo += 1u8; }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

trunk/src/lib/uint.rs

@@ -40,9 +40,8 @@ fn max(x: uint, y: uint) -> uint { if x > y { ret x; } ret y; }
 
 fn min(x: uint, y: uint) -> uint { if x > y { ret y; } ret x; }
 
-iter range(lo: uint, hi: uint) -> uint {
-    let lo_ = lo;
-    while lo_ < hi { put lo_; lo_ += 1u; }
+fn range(lo: uint, hi: uint, it: block(uint)) {
+    while lo < hi { it(lo); lo += 1u; }
 }
 
 fn next_power_of_two(n: uint) -> uint {

trunk/src/lib/vec.rs

@@ -343,9 +343,9 @@ fn eachi<@T>(f: block(T, uint) -> (), v: [mutable? T]) {
 }
 
 // Iterate over a list with with the indexes
-iter iter2<@T>(v: [T]) -> (uint, T) {
+fn iter2<@T>(v: [T], it: block(uint, T)) {
     let i = 0u;
-    for x in v { put (i, x); i += 1u; }
+    for x in v { it(i, x); i += 1u; }
 }
 
 mod unsafe {