Skip to content

Commit b18bd78

Browse files
author
blake2-ppc
committed
std: Replace for with do { .. } expr where internal iterators are used
1 parent 02bdf90 commit b18bd78

File tree

9 files changed

+96
-78
lines changed

9 files changed

+96
-78
lines changed

‎src/libextra/serialize.rs

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -784,11 +784,12 @@ impl<
784784
fn encode(&self, e: &mut E) {
785785
do e.emit_map(self.len()) |e| {
786786
let mut i = 0;
787-
for self.each |key, val| {
787+
do self.each |key, val| {
788788
e.emit_map_elt_key(i, |e| key.encode(e));
789789
e.emit_map_elt_val(i, |e| val.encode(e));
790790
i += 1;
791-
}
791+
true
792+
};
792793
}
793794
}
794795
}
@@ -814,10 +815,11 @@ impl<S: Encoder> Encodable<S> for TrieSet {
814815
fn encode(&self, s: &mut S) {
815816
do s.emit_seq(self.len()) |s| {
816817
let mut i = 0;
817-
for self.each |e| {
818+
do self.each |e| {
818819
s.emit_seq_elt(i, |s| e.encode(s));
819820
i += 1;
820-
}
821+
true
822+
};
821823
}
822824
}
823825
}

‎src/libstd/cleanup.rs

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -94,42 +94,45 @@ pub unsafe fn annihilate() {
9494
//
9595
// In this pass, nothing gets freed, so it does not matter whether
9696
// we read the next field before or after the callback.
97-
for each_live_alloc(true) |box, uniq| {
97+
do each_live_alloc(true) |box, uniq| {
9898
stats.n_total_boxes += 1;
9999
if uniq {
100100
stats.n_unique_boxes += 1;
101101
} else {
102102
(*box).ref_count = managed::RC_IMMORTAL;
103103
}
104-
}
104+
true
105+
};
105106

106107
// Pass 2: Drop all boxes.
107108
//
108109
// In this pass, unique-managed boxes may get freed, but not
109110
// managed boxes, so we must read the `next` field *after* the
110111
// callback, as the original value may have been freed.
111-
for each_live_alloc(false) |box, uniq| {
112+
do each_live_alloc(false) |box, uniq| {
112113
if !uniq {
113114
let tydesc = (*box).type_desc;
114115
let data = &(*box).data as *();
115116
((*tydesc).drop_glue)(data as *i8);
116117
}
117-
}
118+
true
119+
};
118120

119121
// Pass 3: Free all boxes.
120122
//
121123
// In this pass, managed boxes may get freed (but not
122124
// unique-managed boxes, though I think that none of those are
123125
// left), so we must read the `next` field before, since it will
124126
// not be valid after.
125-
for each_live_alloc(true) |box, uniq| {
127+
do each_live_alloc(true) |box, uniq| {
126128
if !uniq {
127129
stats.n_bytes_freed +=
128130
(*((*box).type_desc)).size
129131
+ sys::size_of::<raw::Box<()>>();
130132
local_free(box as *i8);
131133
}
132-
}
134+
true
135+
};
133136

134137
if debug_mem() {
135138
// We do logging here w/o allocation.

‎src/libstd/hashmap.rs

Lines changed: 16 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -130,33 +130,35 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
130130
hash: uint,
131131
k: &K)
132132
-> SearchResult {
133-
for self.bucket_sequence(hash) |i| {
133+
let mut ret = TableFull;
134+
do self.bucket_sequence(hash) |i| {
134135
match self.buckets[i] {
135-
Some(ref bkt) => if bkt.hash == hash && *k == bkt.key {
136-
return FoundEntry(i);
136+
Some(ref bkt) if bkt.hash == hash && *k == bkt.key => {
137+
ret = FoundEntry(i); false
137138
},
138-
None => return FoundHole(i)
139+
None => { ret = FoundHole(i); false }
140+
_ => true,
139141
}
140-
}
141-
TableFull
142+
};
143+
ret
142144
}
143145

144146
#[inline]
145147
fn bucket_for_key_with_hash_equiv<Q:Equiv<K>>(&self,
146148
hash: uint,
147149
k: &Q)
148150
-> SearchResult {
149-
for self.bucket_sequence(hash) |i| {
151+
let mut ret = TableFull;
152+
do self.bucket_sequence(hash) |i| {
150153
match self.buckets[i] {
151-
Some(ref bkt) => {
152-
if bkt.hash == hash && k.equiv(&bkt.key) {
153-
return FoundEntry(i);
154-
}
154+
Some(ref bkt) if bkt.hash == hash && k.equiv(&bkt.key) => {
155+
ret = FoundEntry(i); false
155156
},
156-
None => return FoundHole(i)
157+
None => { ret = FoundHole(i); false }
158+
_ => true,
157159
}
158-
}
159-
TableFull
160+
};
161+
ret
160162
}
161163

162164
/// Expand the capacity of the array to the next power of two
@@ -272,11 +274,6 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
272274

273275
value
274276
}
275-
276-
fn search(&self, hash: uint,
277-
op: &fn(x: &Option<Bucket<K, V>>) -> bool) {
278-
let _ = self.bucket_sequence(hash, |i| op(&self.buckets[i]));
279-
}
280277
}
281278

282279
impl<K:Hash + Eq,V> Container for HashMap<K, V> {

‎src/libstd/io.rs

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -770,9 +770,10 @@ impl<T:Reader> ReaderUtil for T {
770770

771771
fn read_lines(&self) -> ~[~str] {
772772
do vec::build |push| {
773-
for self.each_line |line| {
773+
do self.each_line |line| {
774774
push(line.to_owned());
775-
}
775+
true
776+
};
776777
}
777778
}
778779

@@ -1880,16 +1881,16 @@ mod tests {
18801881

18811882
{
18821883
let file = io::file_reader(&path).unwrap();
1883-
for file.each_byte() |_| {
1884-
fail!("must be empty");
1885-
}
1884+
do file.each_byte() |_| {
1885+
fail!("must be empty")
1886+
};
18861887
}
18871888

18881889
{
18891890
let file = io::file_reader(&path).unwrap();
1890-
for file.each_char() |_| {
1891-
fail!("must be empty");
1892-
}
1891+
do file.each_char() |_| {
1892+
fail!("must be empty")
1893+
};
18931894
}
18941895
}
18951896

‎src/libstd/os.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -790,7 +790,7 @@ pub fn list_dir_path(p: &Path) -> ~[Path] {
790790
/// all its contents. Use carefully!
791791
pub fn remove_dir_recursive(p: &Path) -> bool {
792792
let mut error_happened = false;
793-
for walk_dir(p) |inner| {
793+
do walk_dir(p) |inner| {
794794
if !error_happened {
795795
if path_is_dir(inner) {
796796
if !remove_dir_recursive(inner) {
@@ -803,6 +803,7 @@ pub fn remove_dir_recursive(p: &Path) -> bool {
803803
}
804804
}
805805
}
806+
true
806807
};
807808
// Directory should now be empty
808809
!error_happened && remove_dir(p)

‎src/libstd/task/spawn.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -372,8 +372,9 @@ impl Drop for Taskgroup {
372372
// with our own taskgroup, so long as both happen before we die.
373373
// We remove ourself from every ancestor we can, so no cleanup; no
374374
// break.
375-
for each_ancestor(&mut this.ancestors, |_| {}) |ancestor_group| {
375+
do each_ancestor(&mut this.ancestors, |_| {}) |ancestor_group| {
376376
leave_taskgroup(ancestor_group, &me, false);
377+
true
377378
};
378379
}
379380
}

‎src/libstd/trie.rs

Lines changed: 29 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -459,11 +459,12 @@ mod test_map {
459459
assert!(m.insert(1, 2));
460460

461461
let mut n = 0;
462-
for m.each |k, v| {
462+
do m.each |k, v| {
463463
assert_eq!(*k, n);
464464
assert_eq!(*v, n * 2);
465465
n += 1;
466-
}
466+
true
467+
};
467468
}
468469

469470
#[test]
@@ -475,14 +476,16 @@ mod test_map {
475476
}
476477

477478
let mut n = uint::max_value - 10000;
478-
for m.each |k, v| {
479-
if n == uint::max_value - 5000 { break }
480-
assert!(n < uint::max_value - 5000);
481-
482-
assert_eq!(*k, n);
483-
assert_eq!(*v, n / 2);
484-
n += 1;
485-
}
479+
do m.each |k, v| {
480+
if n == uint::max_value - 5000 { false } else {
481+
assert!(n < uint::max_value - 5000);
482+
483+
assert_eq!(*k, n);
484+
assert_eq!(*v, n / 2);
485+
n += 1;
486+
true
487+
}
488+
};
486489
}
487490

488491
#[test]
@@ -496,11 +499,12 @@ mod test_map {
496499
assert!(m.insert(1, 2));
497500

498501
let mut n = 4;
499-
for m.each_reverse |k, v| {
502+
do m.each_reverse |k, v| {
500503
assert_eq!(*k, n);
501504
assert_eq!(*v, n * 2);
502505
n -= 1;
503-
}
506+
true
507+
};
504508
}
505509

506510
#[test]
@@ -512,14 +516,16 @@ mod test_map {
512516
}
513517

514518
let mut n = uint::max_value - 1;
515-
for m.each_reverse |k, v| {
516-
if n == uint::max_value - 5000 { break }
517-
assert!(n > uint::max_value - 5000);
518-
519-
assert_eq!(*k, n);
520-
assert_eq!(*v, n / 2);
521-
n -= 1;
522-
}
519+
do m.each_reverse |k, v| {
520+
if n == uint::max_value - 5000 { false } else {
521+
assert!(n > uint::max_value - 5000);
522+
523+
assert_eq!(*k, n);
524+
assert_eq!(*v, n / 2);
525+
n -= 1;
526+
true
527+
}
528+
};
523529
}
524530

525531
#[test]
@@ -572,10 +578,11 @@ mod test_set {
572578

573579
let mut i = 0;
574580

575-
for trie.each |x| {
581+
do trie.each |x| {
576582
assert_eq!(expected[i], *x);
577583
i += 1;
578-
}
584+
true
585+
};
579586
}
580587

581588
#[test]

‎src/libstd/vec.rs

Lines changed: 19 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -2767,19 +2767,19 @@ mod tests {
27672767
let mut results: ~[~[int]];
27682768

27692769
results = ~[];
2770-
for each_permutation([]) |v| { results.push(v.to_owned()); }
2770+
do each_permutation([]) |v| { results.push(v.to_owned()); true };
27712771
assert_eq!(results, ~[~[]]);
27722772

27732773
results = ~[];
2774-
for each_permutation([7]) |v| { results.push(v.to_owned()); }
2774+
do each_permutation([7]) |v| { results.push(v.to_owned()); true };
27752775
assert_eq!(results, ~[~[7]]);
27762776

27772777
results = ~[];
2778-
for each_permutation([1,1]) |v| { results.push(v.to_owned()); }
2778+
do each_permutation([1,1]) |v| { results.push(v.to_owned()); true };
27792779
assert_eq!(results, ~[~[1,1],~[1,1]]);
27802780

27812781
results = ~[];
2782-
for each_permutation([5,2,0]) |v| { results.push(v.to_owned()); }
2782+
do each_permutation([5,2,0]) |v| { results.push(v.to_owned()); true };
27832783
assert!(results ==
27842784
~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]);
27852785
}
@@ -3107,12 +3107,13 @@ mod tests {
31073107
fn test_permute_fail() {
31083108
let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
31093109
let mut i = 0;
3110-
for each_permutation(v) |_elt| {
3110+
do each_permutation(v) |_elt| {
31113111
if i == 2 {
31123112
fail!()
31133113
}
31143114
i += 0;
3115-
}
3115+
true
3116+
};
31163117
}
31173118

31183119
#[test]
@@ -3425,39 +3426,43 @@ mod tests {
34253426
fn test_permutations0() {
34263427
let values = [];
34273428
let mut v : ~[~[int]] = ~[];
3428-
for each_permutation(values) |p| {
3429+
do each_permutation(values) |p| {
34293430
v.push(p.to_owned());
3430-
}
3431+
true
3432+
};
34313433
assert_eq!(v, ~[~[]]);
34323434
}
34333435

34343436
#[test]
34353437
fn test_permutations1() {
34363438
let values = [1];
34373439
let mut v : ~[~[int]] = ~[];
3438-
for each_permutation(values) |p| {
3440+
do each_permutation(values) |p| {
34393441
v.push(p.to_owned());
3440-
}
3442+
true
3443+
};
34413444
assert_eq!(v, ~[~[1]]);
34423445
}
34433446

34443447
#[test]
34453448
fn test_permutations2() {
34463449
let values = [1,2];
34473450
let mut v : ~[~[int]] = ~[];
3448-
for each_permutation(values) |p| {
3451+
do each_permutation(values) |p| {
34493452
v.push(p.to_owned());
3450-
}
3453+
true
3454+
};
34513455
assert_eq!(v, ~[~[1,2],~[2,1]]);
34523456
}
34533457

34543458
#[test]
34553459
fn test_permutations3() {
34563460
let values = [1,2,3];
34573461
let mut v : ~[~[int]] = ~[];
3458-
for each_permutation(values) |p| {
3462+
do each_permutation(values) |p| {
34593463
v.push(p.to_owned());
3460-
}
3464+
true
3465+
};
34613466
assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
34623467
}
34633468

0 commit comments

Comments
 (0)