diff options
| author | Patrick Walton <pcwalton@mimiga.net> | 2013-11-20 14:17:12 -0800 |
|---|---|---|
| committer | Patrick Walton <pcwalton@mimiga.net> | 2013-11-26 08:23:57 -0800 |
| commit | 1eca34de7dd55719cd83153994e5caf2027f62a2 (patch) | |
| tree | 14ba2903a9ead6e569d08a33c9ebfc2c6ba07e9e | |
| parent | 6801bc8f552ce740deb60212903ba43de197689c (diff) | |
| download | rust-1eca34de7dd55719cd83153994e5caf2027f62a2.tar.gz rust-1eca34de7dd55719cd83153994e5caf2027f62a2.zip | |
libstd: Remove all non-`proc` uses of `do` from libstd
56 files changed, 722 insertions, 895 deletions
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 5d4f6ee1121..18b6a1ef52a 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -290,7 +290,7 @@ impl<'self> AsciiStr for &'self [Ascii] { #[inline] fn eq_ignore_case(self, other: &[Ascii]) -> bool { - do self.iter().zip(other.iter()).all |(&a, &b)| { a.eq_ignore_case(b) } + self.iter().zip(other.iter()).all(|(&a, &b)| a.eq_ignore_case(b)) } } diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs index a052ae87a41..4405d5be388 100644 --- a/src/libstd/at_vec.rs +++ b/src/libstd/at_vec.rs @@ -56,24 +56,24 @@ pub fn build<A>(size: Option<uint>, builder: |push: |v: A||) -> @[A] { /// `lhs`. Afterwards, the `lhs` is then returned for use again. #[inline] pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] { - do build(Some(lhs.len() + rhs.len())) |push| { + build(Some(lhs.len() + rhs.len()), |push| { for x in lhs.iter() { push((*x).clone()); } for elt in rhs.iter() { push(elt.clone()); } - } + }) } /// Apply a function to each element of a vector and return the results pub fn map<T, U>(v: &[T], f: |x: &T| -> U) -> @[U] { - do build(Some(v.len())) |push| { + build(Some(v.len()), |push| { for elem in v.iter() { push(f(elem)); } - } + }) } /** @@ -83,10 +83,10 @@ pub fn map<T, U>(v: &[T], f: |x: &T| -> U) -> @[U] { * to the value returned by the function `op`. */ pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> @[T] { - do build(Some(n_elts)) |push| { + build(Some(n_elts), |push| { let mut i: uint = 0u; while i < n_elts { push(op(i)); i += 1u; } - } + }) } /** @@ -96,13 +96,13 @@ pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> @[T] { * to the value `t`. */ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> @[T] { - do build(Some(n_elts)) |push| { + build(Some(n_elts), |push| { let mut i: uint = 0u; while i < n_elts { push(t.clone()); i += 1u; } - } + }) } /** @@ -137,11 +137,11 @@ impl<T> Clone for @[T] { impl<A> FromIterator<A> for @[A] { fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> @[A] { let (lower, _) = iterator.size_hint(); - do build(Some(lower)) |push| { + build(Some(lower), |push| { for x in *iterator { push(x); } - } + }) } } @@ -259,9 +259,9 @@ pub mod raw { use rt::local::Local; use rt::task::Task; - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { task.heap.realloc(ptr as *mut Box<()>, size) as *() - } + }) } } @@ -295,11 +295,11 @@ mod test { fn test() { // Some code that could use that, then: fn seq_range(lo: uint, hi: uint) -> @[uint] { - do build(None) |push| { + build(None, |push| { for i in range(lo, hi) { push(i); } - } + }) } assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]); @@ -333,9 +333,7 @@ mod test { #[bench] fn bench_capacity(b: &mut bh) { let x = @[1, 2, 3]; - do b.iter { - capacity(x); - } + b.iter(|| capacity(x)); } #[bench] @@ -359,54 +357,42 @@ mod test { fn bench_append(b: &mut bh) { let lhs = @[7, ..128]; let rhs = range(0, 256).to_owned_vec(); - do b.iter { - append(lhs, rhs); - } + b.iter(|| append(lhs, rhs)) } #[bench] fn bench_map(b: &mut bh) { let elts = range(0, 256).to_owned_vec(); - do b.iter { - map(elts, |x| x*2); - } + b.iter(|| map(elts, |x| x*2)) } #[bench] fn bench_from_fn(b: &mut bh) { - do b.iter { - from_fn(1024, |x| x); - } + b.iter(|| from_fn(1024, |x| x)); } #[bench] fn bench_from_elem(b: &mut bh) { - do b.iter { - from_elem(1024, 0u64); - } + b.iter(|| from_elem(1024, 0u64)); } #[bench] fn bench_to_managed_move(b: &mut bh) { - do b.iter { + b.iter(|| { let elts = range(0, 1024).to_owned_vec(); // yikes! can't move out of capture, though to_managed_move(elts); - } + }) } #[bench] fn bench_to_managed(b: &mut bh) { let elts = range(0, 1024).to_owned_vec(); - do b.iter { - to_managed(elts); - } + b.iter(|| to_managed(elts)); } #[bench] fn bench_clone(b: &mut bh) { let elts = to_managed(range(0, 1024).to_owned_vec()); - do b.iter { - elts.clone(); - } + b.iter(|| elts.clone()); } } diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index a9c4d2cacde..306ee331929 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -49,15 +49,15 @@ let my_string = "Hello, world!"; // Allocate the C string with an explicit local that owns the string. The // `c_buffer` pointer will be deallocated when `my_c_string` goes out of scope. let my_c_string = my_string.to_c_str(); -do my_c_string.with_ref |c_buffer| { +my_c_string.with_ref(|c_buffer| { unsafe { puts(c_buffer); } -} +}) // Don't save off the allocation of the C string, the `c_buffer` will be // deallocated when this block returns! -do my_string.with_c_str |c_buffer| { +my_string.with_c_str(|c_buffer| { unsafe { puts(c_buffer); } -} +}) ``` */ @@ -262,14 +262,12 @@ static BUF_LEN: uint = 128; impl<'self> ToCStr for &'self [u8] { fn to_c_str(&self) -> CString { let mut cs = unsafe { self.to_c_str_unchecked() }; - do cs.with_mut_ref |buf| { - check_for_null(*self, buf); - } + cs.with_mut_ref(|buf| check_for_null(*self, buf)); cs } unsafe fn to_c_str_unchecked(&self) -> CString { - do self.as_imm_buf |self_buf, self_len| { + self.as_imm_buf(|self_buf, self_len| { let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8; if buf.is_null() { fail!("failed to allocate memory!"); @@ -279,7 +277,7 @@ impl<'self> ToCStr for &'self [u8] { *ptr::mut_offset(buf, self_len as int) = 0; CString::new(buf as *libc::c_char, true) - } + }) } fn with_c_str<T>(&self, f: |*libc::c_char| -> T) -> T { @@ -298,13 +296,13 @@ unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T { vec::bytes::copy_memory(buf, v, v.len()); buf[v.len()] = 0; - do buf.as_mut_buf |buf, _| { + buf.as_mut_buf(|buf, _| { if checked { check_for_null(v, buf as *mut libc::c_char); } f(buf as *libc::c_char) - } + }) } else if checked { v.to_c_str().with_ref(f) } else { @@ -390,10 +388,10 @@ mod tests { let ptr = vec::raw::to_ptr(input); let expected = ["zero", "one"]; let mut it = expected.iter(); - let result = do from_c_multistring(ptr as *libc::c_char, None) |c| { + let result = from_c_multistring(ptr as *libc::c_char, None, |c| { let cbytes = c.as_bytes().slice_to(c.len()); assert_eq!(cbytes, it.next().unwrap().as_bytes()); - }; + }); assert_eq!(result, 2); assert!(it.next().is_none()); } @@ -401,13 +399,13 @@ mod tests { #[test] fn test_str_to_c_str() { - do "".to_c_str().with_ref |buf| { + "".to_c_str().with_ref(|buf| { unsafe { assert_eq!(*ptr::offset(buf, 0), 0); } - } + }); - do "hello".to_c_str().with_ref |buf| { + "hello".to_c_str().with_ref(|buf| { unsafe { assert_eq!(*ptr::offset(buf, 0), 'h' as libc::c_char); assert_eq!(*ptr::offset(buf, 1), 'e' as libc::c_char); @@ -416,19 +414,19 @@ mod tests { assert_eq!(*ptr::offset(buf, 4), 'o' as libc::c_char); assert_eq!(*ptr::offset(buf, 5), 0); } - } + }) } #[test] fn test_vec_to_c_str() { let b: &[u8] = []; - do b.to_c_str().with_ref |buf| { + b.to_c_str().with_ref(|buf| { unsafe { assert_eq!(*ptr::offset(buf, 0), 0); } - } + }); - do bytes!("hello").to_c_str().with_ref |buf| { + let _ = bytes!("hello").to_c_str().with_ref(|buf| { unsafe { assert_eq!(*ptr::offset(buf, 0), 'h' as libc::c_char); assert_eq!(*ptr::offset(buf, 1), 'e' as libc::c_char); @@ -437,9 +435,9 @@ mod tests { assert_eq!(*ptr::offset(buf, 4), 'o' as libc::c_char); assert_eq!(*ptr::offset(buf, 5), 0); } - } + }); - do bytes!("foo", 0xff).to_c_str().with_ref |buf| { + let _ = bytes!("foo", 0xff).to_c_str().with_ref(|buf| { unsafe { assert_eq!(*ptr::offset(buf, 0), 'f' as libc::c_char); assert_eq!(*ptr::offset(buf, 1), 'o' as libc::c_char); @@ -447,7 +445,7 @@ mod tests { assert_eq!(*ptr::offset(buf, 3), 0xff); assert_eq!(*ptr::offset(buf, 4), 0); } - } + }); } #[test] @@ -500,18 +498,16 @@ mod tests { use c_str::null_byte::cond; let mut error_happened = false; - do cond.trap(|err| { + cond.trap(|err| { assert_eq!(err, bytes!("he", 0, "llo").to_owned()) error_happened = true; Truncate - }).inside { - "he\x00llo".to_c_str() - }; + }).inside(|| "he\x00llo".to_c_str()); assert!(error_happened); - do cond.trap(|_| { + cond.trap(|_| { ReplaceWith('?' as libc::c_char) - }).inside(|| "he\x00llo".to_c_str()).with_ref |buf| { + }).inside(|| "he\x00llo".to_c_str()).with_ref(|buf| { unsafe { assert_eq!(*buf.offset(0), 'h' as libc::c_char); assert_eq!(*buf.offset(1), 'e' as libc::c_char); @@ -521,13 +517,13 @@ mod tests { assert_eq!(*buf.offset(5), 'o' as libc::c_char); assert_eq!(*buf.offset(6), 0); } - } + }) } #[test] fn test_to_c_str_unchecked() { unsafe { - do "he\x00llo".to_c_str_unchecked().with_ref |buf| { + "he\x00llo".to_c_str_unchecked().with_ref(|buf| { assert_eq!(*buf.offset(0), 'h' as libc::c_char); assert_eq!(*buf.offset(1), 'e' as libc::c_char); assert_eq!(*buf.offset(2), 0); @@ -535,7 +531,7 @@ mod tests { assert_eq!(*buf.offset(4), 'l' as libc::c_char); assert_eq!(*buf.offset(5), 'o' as libc::c_char); assert_eq!(*buf.offset(6), 0); - } + }) } } @@ -579,7 +575,7 @@ mod bench { #[inline] fn check(s: &str, c_str: *libc::c_char) { - do s.as_imm_buf |s_buf, s_len| { + s.as_imm_buf(|s_buf, s_len| { for i in range(0, s_len) { unsafe { assert_eq!( @@ -587,7 +583,7 @@ mod bench { *ptr::offset(c_str, i as int)); } } - } + }) } static s_short: &'static str = "Mary"; @@ -601,12 +597,10 @@ mod bench { Mary had a little lamb, Little lamb"; fn bench_to_str(bh: &mut BenchHarness, s: &str) { - do bh.iter { + bh.iter(|| { let c_str = s.to_c_str(); - do c_str.with_ref |c_str_buf| { - check(s, c_str_buf) - } - } + c_str.with_ref(|c_str_buf| check(s, c_str_buf)) + }) } #[bench] @@ -625,12 +619,10 @@ mod bench { } fn bench_to_c_str_unchecked(bh: &mut BenchHarness, s: &str) { - do bh.iter { + bh.iter(|| { let c_str = unsafe { s.to_c_str_unchecked() }; - do c_str.with_ref |c_str_buf| { - check(s, c_str_buf) - } - } + c_str.with_ref(|c_str_buf| check(s, c_str_buf)) + }) } #[bench] @@ -649,11 +641,9 @@ mod bench { } fn bench_with_c_str(bh: &mut BenchHarness, s: &str) { - do bh.iter { - do s.with_c_str |c_str_buf| { - check(s, c_str_buf) - } - } + bh.iter(|| { + s.with_c_str(|c_str_buf| check(s, c_str_buf)) + }) } #[bench] @@ -672,13 +662,11 @@ mod bench { } fn bench_with_c_str_unchecked(bh: &mut BenchHarness, s: &str) { - do bh.iter { + bh.iter(|| { unsafe { - do s.with_c_str_unchecked |c_str_buf| { - check(s, c_str_buf) - } + s.with_c_str_unchecked(|c_str_buf| check(s, c_str_buf)) } - } + }) } #[bench] diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index e49cf3e5303..634558b9b97 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -82,6 +82,7 @@ pub struct RefCell<T> { priv nc: NonCopyable } +<<<<<<< HEAD // Values [1, MAX-1] represent the number of `Ref` active // (will not outgrow its range since `uint` is the size of the address space) type BorrowFlag = uint; diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs index 2f7b27b55e3..7c972ed86b4 100644 --- a/src/libstd/cleanup.rs +++ b/src/libstd/cleanup.rs @@ -82,7 +82,7 @@ pub unsafe fn annihilate() { // // In this pass, nothing gets freed, so it does not matter whether // we read the next field before or after the callback. - do each_live_alloc(true) |box, uniq| { + each_live_alloc(true, |box, uniq| { stats.n_total_boxes += 1; if uniq { stats.n_unique_boxes += 1; @@ -90,21 +90,21 @@ pub unsafe fn annihilate() { (*box).ref_count = managed::RC_IMMORTAL; } true - }; + }); // Pass 2: Drop all boxes. // // In this pass, unique-managed boxes may get freed, but not // managed boxes, so we must read the `next` field *after* the // callback, as the original value may have been freed. - do each_live_alloc(false) |box, uniq| { + each_live_alloc(false, |box, uniq| { if !uniq { let tydesc = (*box).type_desc; let data = &(*box).data as *(); ((*tydesc).drop_glue)(data as *i8); } true - }; + }); // Pass 3: Free all boxes. // @@ -112,7 +112,7 @@ pub unsafe fn annihilate() { // unique-managed boxes, though I think that none of those are // left), so we must read the `next` field before, since it will // not be valid after. - do each_live_alloc(true) |box, uniq| { + each_live_alloc(true, |box, uniq| { if !uniq { stats.n_bytes_freed += (*((*box).type_desc)).size @@ -120,7 +120,7 @@ pub unsafe fn annihilate() { local_free(box as *i8); } true - }; + }); if debug_mem() { // We do logging here w/o allocation. diff --git a/src/libstd/either.rs b/src/libstd/either.rs index d2874a6f7f5..6d152d8c179 100644 --- a/src/libstd/either.rs +++ b/src/libstd/either.rs @@ -209,23 +209,23 @@ pub type Rights<L, R, Iter> = FilterMap<'static, Either<L, R>, R, Iter>; /// Extracts all the left values pub fn lefts<L, R, Iter: Iterator<Either<L, R>>>(eithers: Iter) -> Lefts<L, R, Iter> { - do eithers.filter_map |elt| { + eithers.filter_map(|elt| { match elt { Left(x) => Some(x), _ => None, } - } + }) } /// Extracts all the right values pub fn rights<L, R, Iter: Iterator<Either<L, R>>>(eithers: Iter) -> Rights<L, R, Iter> { - do eithers.filter_map |elt| { + eithers.filter_map(|elt| { match elt { Right(x) => Some(x), _ => None, } - } + }) } diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index 427690a4aa5..33ef4731405 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -801,12 +801,12 @@ impl<'self> Formatter<'self> { } fn runplural(&mut self, value: uint, pieces: &[rt::Piece]) { - do ::uint::to_str_bytes(value, 10) |buf| { + ::uint::to_str_bytes(value, 10, |buf| { let valuestr = str::from_utf8_slice(buf); for piece in pieces.iter() { self.run(piece, Some(valuestr)); } - } + }) } // Helper methods used for padding and processing formatting arguments that @@ -868,9 +868,9 @@ impl<'self> Formatter<'self> { self.fill = '0'; sign(self); } - do self.with_padding(min - actual_len, parse::AlignRight) |me| { + self.with_padding(min - actual_len, parse::AlignRight, |me| { emit(me); - } + }) } } } @@ -924,9 +924,9 @@ impl<'self> Formatter<'self> { // If we're under both the maximum and the minimum width, then fill // up the minimum width with the specified string + some alignment. Some(width) => { - do self.with_padding(width - s.len(), parse::AlignLeft) |me| { + self.with_padding(width - s.len(), parse::AlignLeft, |me| { me.buf.write(s.as_bytes()); - } + }) } } } @@ -1007,18 +1007,18 @@ macro_rules! int_base(($ty:ident, $into:ident, $base:expr, $name:ident, $prefix:expr) => { impl $name for $ty { fn fmt(c: &$ty, f: &mut Formatter) { - do ::$into::to_str_bytes(*c as $into, $base) |buf| { + ::$into::to_str_bytes(*c as $into, $base, |buf| { f.pad_integral(buf, $prefix, true); - } + }) } } }) macro_rules! upper_hex(($ty:ident, $into:ident) => { impl UpperHex for $ty { fn fmt(c: &$ty, f: &mut Formatter) { - do ::$into::to_str_bytes(*c as $into, 16) |buf| { + ::$into::to_str_bytes(*c as $into, 16, |buf| { upperhex(buf, f); - } + }) } } }) @@ -1045,9 +1045,9 @@ macro_rules! integer(($signed:ident, $unsigned:ident) => { // nothing else should do that, however. impl Signed for $signed { fn fmt(c: &$signed, f: &mut Formatter) { - do ::$unsigned::to_str_bytes(c.abs() as $unsigned, 10) |buf| { + ::$unsigned::to_str_bytes(c.abs() as $unsigned, 10, |buf| { f.pad_integral(buf, "", *c >= 0); - } + }) } } int_base!($signed, $unsigned, 2, Binary, "0b") @@ -1104,9 +1104,9 @@ impl<T> Poly for T { impl<T> Pointer for *T { fn fmt(t: &*T, f: &mut Formatter) { f.flags |= 1 << (parse::FlagAlternate as uint); - do ::uint::to_str_bytes(*t as uint, 16) |buf| { + ::uint::to_str_bytes(*t as uint, 16, |buf| { f.pad_integral(buf, "0x", true); - } + }) } } impl<T> Pointer for *mut T { diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs index f15abff8316..5a671eea7a3 100644 --- a/src/libstd/hash.rs +++ b/src/libstd/hash.rs @@ -83,10 +83,10 @@ impl<A:IterBytes> Hash for A { #[inline] fn hash_keyed(&self, k0: u64, k1: u64) -> u64 { let mut s = State::new(k0, k1); - do self.iter_bytes(true) |bytes| { + self.iter_bytes(true, |bytes| { s.input(bytes); true - }; + }); s.result_u64() } } @@ -94,14 +94,14 @@ impl<A:IterBytes> Hash for A { fn hash_keyed_2<A: IterBytes, B: IterBytes>(a: &A, b: &B, k0: u64, k1: u64) -> u64 { let mut s = State::new(k0, k1); - do a.iter_bytes(true) |bytes| { + a.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do b.iter_bytes(true) |bytes| { + }); + b.iter_bytes(true, |bytes| { s.input(bytes); true - }; + }); s.result_u64() } @@ -109,18 +109,18 @@ fn hash_keyed_3<A: IterBytes, B: IterBytes, C: IterBytes>(a: &A, b: &B, c: &C, k0: u64, k1: u64) -> u64 { let mut s = State::new(k0, k1); - do a.iter_bytes(true) |bytes| { + a.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do b.iter_bytes(true) |bytes| { + }); + b.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do c.iter_bytes(true) |bytes| { + }); + c.iter_bytes(true, |bytes| { s.input(bytes); true - }; + }); s.result_u64() } @@ -136,22 +136,22 @@ fn hash_keyed_4<A: IterBytes, k1: u64) -> u64 { let mut s = State::new(k0, k1); - do a.iter_bytes(true) |bytes| { + a.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do b.iter_bytes(true) |bytes| { + }); + b.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do c.iter_bytes(true) |bytes| { + }); + c.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do d.iter_bytes(true) |bytes| { + }); + d.iter_bytes(true, |bytes| { s.input(bytes); true - }; + }); s.result_u64() } @@ -169,26 +169,26 @@ fn hash_keyed_5<A: IterBytes, k1: u64) -> u64 { let mut s = State::new(k0, k1); - do a.iter_bytes(true) |bytes| { + a.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do b.iter_bytes(true) |bytes| { + }); + b.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do c.iter_bytes(true) |bytes| { + }); + c.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do d.iter_bytes(true) |bytes| { + }); + d.iter_bytes(true, |bytes| { s.input(bytes); true - }; - do e.iter_bytes(true) |bytes| { + }); + e.iter_bytes(true, |bytes| { s.input(bytes); true - }; + }); s.result_u64() } diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 0bc1aa89353..a61871cbb5e 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -110,7 +110,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> { k: &K) -> SearchResult { let mut ret = TableFull; - do self.bucket_sequence(hash) |i| { + self.bucket_sequence(hash, |i| { match self.buckets[i] { Some(ref bkt) if bkt.hash == hash && *k == bkt.key => { ret = FoundEntry(i); false @@ -118,7 +118,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> { None => { ret = FoundHole(i); false } _ => true, } - }; + }); ret } @@ -128,7 +128,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> { k: &Q) -> SearchResult { let mut ret = TableFull; - do self.bucket_sequence(hash) |i| { + self.bucket_sequence(hash, |i| { match self.buckets[i] { Some(ref bkt) if bkt.hash == hash && k.equiv(&bkt.key) => { ret = FoundEntry(i); false @@ -136,7 +136,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> { None => { ret = FoundHole(i); false } _ => true, } - }; + }); ret } @@ -236,9 +236,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> { let len_buckets = self.buckets.len(); let bucket = self.buckets[idx].take(); - let value = do bucket.map |bucket| { - bucket.value - }; + let value = bucket.map(|bucket| bucket.value); /* re-inserting buckets may cause changes in size, so remember what our new size is ahead of time before we start insertions */ @@ -500,12 +498,12 @@ impl<K:Hash + Eq,V:Eq> Eq for HashMap<K, V> { fn eq(&self, other: &HashMap<K, V>) -> bool { if self.len() != other.len() { return false; } - do self.iter().all |(key, value)| { + self.iter().all(|(key, value)| { match other.find(key) { None => false, Some(v) => value == v } - } + }) } fn ne(&self, other: &HashMap<K, V>) -> bool { !self.eq(other) } diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 930f58ef33f..d1502df047e 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -76,7 +76,7 @@ pub struct File { } fn io_raise<T>(f: |io: &mut IoFactory| -> Result<T, IoError>) -> Option<T> { - do with_local_io |io| { + with_local_io(|io| { match f(io) { Ok(t) => Some(t), Err(ioerr) => { @@ -84,7 +84,7 @@ fn io_raise<T>(f: |io: &mut IoFactory| -> Result<T, IoError>) -> Option<T> { None } } - } + }) } impl File { @@ -97,9 +97,9 @@ impl File { /// /// let p = Path::new("/some/file/path.txt"); /// - /// do io_error::cond.trap(|_| { + /// io_error::cond.trap(|_| { /// // hoo-boy... - /// }).inside { + /// }).inside(|| { /// let file = match File::open_mode(&p, Open, ReadWrite) { /// Some(s) => s, /// None => fail!("whoops! I'm sure this raised, anyways..") @@ -107,7 +107,7 @@ impl File { /// // do some stuff with that file /// /// // the file will be closed at the end of this block - /// } + /// }) /// // .. /// /// `FileMode` and `FileAccess` provide information about the permissions @@ -132,7 +132,7 @@ impl File { pub fn open_mode(path: &Path, mode: FileMode, access: FileAccess) -> Option<File> { - do with_local_io |io| { + with_local_io(|io| { match io.fs_open(&path.to_c_str(), mode, access) { Ok(fd) => Some(File { path: path.clone(), @@ -144,7 +144,7 @@ impl File { None } } - } + }) } /// Attempts to open a file in read-only mode. This function is equivalent to @@ -244,7 +244,7 @@ impl File { /// directory, the user lacks permissions to remove the file, or if some /// other filesystem-level error occurs. pub fn unlink(path: &Path) { - do io_raise |io| { io.fs_unlink(&path.to_c_str()) }; + io_raise(|io| io.fs_unlink(&path.to_c_str())); } /// Given a path, query the file system to get information about a file, @@ -272,9 +272,7 @@ pub fn unlink(path: &Path) { /// requisite permissions to perform a `stat` call on the given path or if /// there is no entry in the filesystem at the provided path. pub fn stat(path: &Path) -> FileStat { - do io_raise |io| { - io.fs_stat(&path.to_c_str()) - }.unwrap_or_else(dummystat) + io_raise(|io| io.fs_stat(&path.to_c_str())).unwrap_or_else(dummystat) } fn dummystat() -> FileStat { @@ -310,9 +308,7 @@ fn dummystat() -> FileStat { /// /// See `stat` pub fn lstat(path: &Path) -> FileStat { - do io_raise |io| { - io.fs_lstat(&path.to_c_str()) - }.unwrap_or_else(dummystat) + io_raise(|io| io.fs_lstat(&path.to_c_str())).unwrap_or_else(dummystat) } /// Rename a file or directory to a new name. @@ -330,9 +326,7 @@ pub fn lstat(path: &Path) -> FileStat { /// the process lacks permissions to view the contents, or if some other /// intermittent I/O error occurs. pub fn rename(from: &Path, to: &Path) { - do io_raise |io| { - io.fs_rename(&from.to_c_str(), &to.to_c_str()) - }; + io_raise(|io| io.fs_rename(&from.to_c_str(), &to.to_c_str())); } /// Copies the contents of one file to another. This function will also @@ -403,9 +397,7 @@ pub fn copy(from: &Path, to: &Path) { /// condition. Some possible error situations are not having the permission to /// change the attributes of a file or the file not existing. pub fn chmod(path: &Path, mode: io::FilePermission) { - do io_raise |io| { - io.fs_chmod(&path.to_c_str(), mode) - }; + io_raise(|io| io.fs_chmod(&path.to_c_str(), mode)); } /// Change the user and group owners of a file at the specified path. @@ -414,7 +406,7 @@ pub fn chmod(path: &Path, mode: io::FilePermission) { /// /// This funtion will raise on the `io_error` condition on failure. pub fn chown(path: &Path, uid: int, gid: int) { - do io_raise |io| { io.fs_chown(&path.to_c_str(), uid, gid) }; + io_raise(|io| io.fs_chown(&path.to_c_str(), uid, gid)); } /// Creates a new hard link on the filesystem. The `dst` path will be a @@ -425,7 +417,7 @@ pub fn chown(path: &Path, uid: int, gid: int) { /// /// This function will raise on the `io_error` condition on failure. pub fn link(src: &Path, dst: &Path) { - do io_raise |io| { io.fs_link(&src.to_c_str(), &dst.to_c_str()) }; + io_raise(|io| io.fs_link(&src.to_c_str(), &dst.to_c_str())); } /// Creates a new symbolic link on the filesystem. The `dst` path will be a @@ -435,7 +427,7 @@ pub fn link(src: &Path, dst: &Path) { /// /// This function will raise on the `io_error` condition on failure. pub fn symlink(src: &Path, dst: &Path) { - do io_raise |io| { io.fs_symlink(&src.to_c_str(), &dst.to_c_str()) }; + io_raise(|io| io.fs_symlink(&src.to_c_str(), &dst.to_c_str())); } /// Reads a symlink, returning the file that the symlink points to. @@ -446,7 +438,7 @@ pub fn symlink(src: &Path, dst: &Path) { /// conditions include reading a file that does not exist or reading a file /// which is not a symlink. pub fn readlink(path: &Path) -> Option<Path> { - do io_raise |io| { io.fs_readlink(&path.to_c_str()) } + io_raise(|io| io.fs_readlink(&path.to_c_str())) } /// Create a new, empty directory at the provided path @@ -466,9 +458,7 @@ pub fn readlink(path: &Path) -> Option<Path> { /// to make a new directory at the provided path, or if the directory already /// exists. pub fn mkdir(path: &Path, mode: FilePermission) { - do io_raise |io| { - io.fs_mkdir(&path.to_c_str(), mode) - }; + io_raise(|io| io.fs_mkdir(&path.to_c_str(), mode)); } /// Remove an existing, empty directory @@ -487,9 +477,7 @@ pub fn mkdir(path: &Path, mode: FilePermission) { /// to remove the directory at the provided path, or if the directory isn't /// empty. pub fn rmdir(path: &Path) { - do io_raise |io| { - io.fs_rmdir(&path.to_c_str()) - }; + io_raise(|io| io.fs_rmdir(&path.to_c_str())); } /// Retrieve a vector containing all entries within a provided directory @@ -516,9 +504,7 @@ pub fn rmdir(path: &Path) { /// the process lacks permissions to view the contents or if the `path` points /// at a non-directory file pub fn readdir(path: &Path) -> ~[Path] { - do io_raise |io| { - io.fs_readdir(&path.to_c_str(), 0) - }.unwrap_or_else(|| ~[]) + io_raise(|io| io.fs_readdir(&path.to_c_str(), 0)).unwrap_or_else(|| ~[]) } /// Returns an iterator which will recursively walk the directory structure @@ -599,9 +585,7 @@ pub fn rmdir_recursive(path: &Path) { /// happens. // FIXME(#10301) these arguments should not be u64 pub fn change_file_times(path: &Path, atime: u64, mtime: u64) { - do io_raise |io| { - io.fs_utime(&path.to_c_str(), atime, mtime) - }; + io_raise(|io| io.fs_utime(&path.to_c_str(), atime, mtime)); } impl Reader for File { @@ -797,12 +781,12 @@ mod test { let tmpdir = tmpdir(); let filename = &tmpdir.join("file_that_does_not_exist.txt"); let mut called = false; - do io_error::cond.trap(|_| { + io_error::cond.trap(|_| { called = true; - }).inside { + }).inside(|| { let result = File::open_mode(filename, Open, Read); assert!(result.is_none()); - } + }); assert!(called); }) @@ -810,11 +794,9 @@ mod test { let tmpdir = tmpdir(); let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt"); let mut called = false; - do io_error::cond.trap(|_| { + io_error::cond.trap(|_| { called = true; - }).inside { - unlink(filename); - } + }).inside(|| unlink(filename)); assert!(called); }) diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 8f66215105a..8cc4e7b389b 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -40,9 +40,9 @@ Some examples of obvious things you might want to do * Iterate over the lines of a file - do File::open("message.txt").each_line |line| { + File::open("message.txt").each_line(|line| { println(line) - } + }) * Pull the lines of a file into a vector of strings @@ -395,13 +395,11 @@ condition! { /// Helper for wrapper calls where you want to /// ignore any io_errors that might be raised pub fn ignore_io_error<T>(cb: || -> T) -> T { - do io_error::cond.trap(|_| { + io_error::cond.trap(|_| { // just swallow the error.. downstream users // who can make a decision based on a None result // won't care - }).inside { - cb() - } + }).inside(|| cb()) } /// Helper for catching an I/O error and wrapping it in a Result object. The @@ -501,7 +499,7 @@ pub trait Reader { buf.reserve_additional(len); vec::raw::set_len(buf, start_len + len); - do (|| { + (|| { while total_read < len { let len = buf.len(); let slice = buf.mut_slice(start_len + total_read, len); @@ -515,9 +513,7 @@ pub trait Reader { } } } - }).finally { - vec::raw::set_len(buf, start_len + total_read); - } + }).finally(|| vec::raw::set_len(buf, start_len + total_read)) } } @@ -542,17 +538,17 @@ pub trait Reader { fn read_to_end(&mut self) -> ~[u8] { let mut buf = vec::with_capacity(DEFAULT_BUF_SIZE); let mut keep_reading = true; - do io_error::cond.trap(|e| { + io_error::cond.trap(|e| { if e.kind == EndOfFile { keep_reading = false; } else { io_error::cond.raise(e) } - }).inside { + }).inside(|| { while keep_reading { self.push_bytes(&mut buf, DEFAULT_BUF_SIZE) } - } + }); return buf; } diff --git a/src/libstd/io/native/file.rs b/src/libstd/io/native/file.rs index abaeab609aa..c21326262e4 100644 --- a/src/libstd/io/native/file.rs +++ b/src/libstd/io/native/file.rs @@ -37,7 +37,7 @@ fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 { #[cfg(windows)] static eintr: int = 0; // doesn't matter #[cfg(not(windows))] static eintr: int = libc::EINTR as int; - let (data, origamt) = do data.as_imm_buf |data, amt| { (data, amt) }; + let (data, origamt) = data.as_imm_buf(|data, amt| (data, amt)); let mut data = data; let mut amt = origamt; while amt > 0 { @@ -83,11 +83,11 @@ impl FileDesc { fn inner_read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> { #[cfg(windows)] type rlen = libc::c_uint; #[cfg(not(windows))] type rlen = libc::size_t; - let ret = do keep_going(buf) |buf, len| { + let ret = keep_going(buf, |buf, len| { unsafe { libc::read(self.fd, buf as *mut libc::c_void, len as rlen) as i64 } - }; + }); if ret == 0 { Err(io::standard_error(io::EndOfFile)) } else if ret < 0 { @@ -99,11 +99,11 @@ impl FileDesc { fn inner_write(&mut self, buf: &[u8]) -> Result<(), IoError> { #[cfg(windows)] type wlen = libc::c_uint; #[cfg(not(windows))] type wlen = libc::size_t; - let ret = do keep_going(buf) |buf, len| { + let ret = keep_going(buf, |buf, len| { unsafe { libc::write(self.fd, buf as *libc::c_void, len as wlen) as i64 } - }; + }); if ret < 0 { Err(super::last_error()) } else { @@ -344,12 +344,12 @@ impl CFile { impl rtio::RtioFileStream for CFile { fn read(&mut self, buf: &mut [u8]) -> Result<int, IoError> { - let ret = do keep_going(buf) |buf, len| { + let ret = keep_going(buf, |buf, len| { unsafe { libc::fread(buf as *mut libc::c_void, 1, len as libc::size_t, self.file) as i64 } - }; + }); if ret == 0 { Err(io::standard_error(io::EndOfFile)) } else if ret < 0 { @@ -360,12 +360,12 @@ impl rtio::RtioFileStream for CFile { } fn write(&mut self, buf: &[u8]) -> Result<(), IoError> { - let ret = do keep_going(buf) |buf, len| { + let ret = keep_going(buf, |buf, len| { unsafe { libc::fwrite(buf as *libc::c_void, 1, len as libc::size_t, self.file) as i64 } - }; + }); if ret < 0 { Err(super::last_error()) } else { @@ -445,9 +445,9 @@ pub fn open(path: &CString, fm: io::FileMode, fa: io::FileAccess) #[cfg(windows)] fn os_open(path: &CString, flags: c_int, mode: c_int) -> c_int { - do as_utf16_p(path.as_str().unwrap()) |path| { + as_utf16_p(path.as_str().unwrap(), |path| { unsafe { libc::wopen(path, flags, mode) } - } + }) } #[cfg(unix)] @@ -463,9 +463,9 @@ pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> { fn os_mkdir(p: &CString, _mode: c_int) -> IoResult<()> { super::mkerr_winbool(unsafe { // FIXME: turn mode into something useful? #2623 - do as_utf16_p(p.as_str().unwrap()) |buf| { + as_utf16_p(p.as_str().unwrap(), |buf| { libc::CreateDirectoryW(buf, ptr::mut_null()) - } + }) }) } @@ -497,9 +497,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> { } debug!("os::list_dir -- BEFORE OPENDIR"); - let dir_ptr = do p.with_ref |buf| { - opendir(buf) - }; + let dir_ptr = p.with_ref(|buf| opendir(buf)); if (dir_ptr as uint != 0) { let mut paths = ~[]; @@ -540,7 +538,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> { let p = CString::new(p.with_ref(|p| p), false); let p = Path::new(p); let star = p.join("*"); - do as_utf16_p(star.as_str().unwrap()) |path_ptr| { + as_utf16_p(star.as_str().unwrap(), |path_ptr| { let wfd_ptr = malloc_raw(rust_list_dir_wfd_size() as uint); let find_handle = FindFirstFileW(path_ptr, wfd_ptr as HANDLE); if find_handle as libc::c_int != INVALID_HANDLE_VALUE { @@ -565,7 +563,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> { } else { Err(super::last_error()) } - } + }) } get_list(p).map(|paths| prune(p, paths)) @@ -578,9 +576,7 @@ pub fn unlink(p: &CString) -> IoResult<()> { #[cfg(windows)] fn os_unlink(p: &CString) -> IoResult<()> { super::mkerr_winbool(unsafe { - do as_utf16_p(p.as_str().unwrap()) |buf| { - libc::DeleteFileW(buf) - } + as_utf16_p(p.as_str().unwrap(), |buf| libc::DeleteFileW(buf)); }) } @@ -596,11 +592,11 @@ pub fn rename(old: &CString, new: &CString) -> IoResult<()> { #[cfg(windows)] fn os_rename(old: &CString, new: &CString) -> IoResult<()> { super::mkerr_winbool(unsafe { - do as_utf16_p(old.as_str().unwrap()) |old| { - do as_utf16_p(new.as_str().unwrap()) |new| { + as_utf16_p(old.as_str().unwrap(), |old| { + as_utf16_p(new.as_str().unwrap(), |new| { libc::MoveFileExW(old, new, libc::MOVEFILE_REPLACE_EXISTING) - } - } + }) + }) }) } @@ -618,9 +614,7 @@ pub fn chmod(p: &CString, mode: io::FilePermission) -> IoResult<()> { #[cfg(windows)] fn os_chmod(p: &CString, mode: c_int) -> c_int { unsafe { - do as_utf16_p(p.as_str().unwrap()) |p| { - libc::wchmod(p, mode) - } + as_utf16_p(p.as_str().unwrap(), |p| libc::wchmod(p, mode)) } } @@ -636,7 +630,7 @@ pub fn rmdir(p: &CString) -> IoResult<()> { #[cfg(windows)] fn os_rmdir(p: &CString) -> c_int { unsafe { - do as_utf16_p(p.as_str().unwrap()) |p| { libc::wrmdir(p) } + as_utf16_p(p.as_str().unwrap(), |p| libc::wrmdir(p)) } } @@ -669,7 +663,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> { #[cfg(windows)] fn os_readlink(p: &CString) -> IoResult<Path> { let handle = unsafe { - do as_utf16_p(p.as_str().unwrap()) |p| { + as_utf16_p(p.as_str().unwrap(), |p| { libc::CreateFileW(p, libc::GENERIC_READ, libc::FILE_SHARE_READ, @@ -677,15 +671,15 @@ pub fn readlink(p: &CString) -> IoResult<Path> { libc::OPEN_EXISTING, libc::FILE_ATTRIBUTE_NORMAL, ptr::mut_null()) - } + }) }; if handle == ptr::mut_null() { return Err(super::last_error()) } - let ret = do fill_utf16_buf_and_decode |buf, sz| { + let ret = fill_utf16_buf_and_decode(|buf, sz| { unsafe { libc::GetFinalPathNameByHandleW(handle, buf as *u16, sz, libc::VOLUME_NAME_NT) } - }; + }); let ret = match ret { Some(s) => Ok(Path::new(s)), None => Err(super::last_error()), @@ -722,11 +716,11 @@ pub fn symlink(src: &CString, dst: &CString) -> IoResult<()> { #[cfg(windows)] fn os_symlink(src: &CString, dst: &CString) -> IoResult<()> { - super::mkerr_winbool(do as_utf16_p(src.as_str().unwrap()) |src| { - do as_utf16_p(dst.as_str().unwrap()) |dst| { + super::mkerr_winbool(as_utf16_p(src.as_str().unwrap(), |src| { + as_utf16_p(dst.as_str().unwrap(), |dst| { unsafe { libc::CreateSymbolicLinkW(dst, src, 0) } - } - }) + }) + })) } #[cfg(unix)] @@ -742,11 +736,11 @@ pub fn link(src: &CString, dst: &CString) -> IoResult<()> { #[cfg(windows)] fn os_link(src: &CString, dst: &CString) -> IoResult<()> { - super::mkerr_winbool(do as_utf16_p(src.as_str().unwrap()) |src| { - do as_utf16_p(dst.as_str().unwrap()) |dst| { + super::mkerr_winbool(as_utf16_p(src.as_str().unwrap(), |src| { + as_utf16_p(dst.as_str().unwrap(), |dst| { unsafe { libc::CreateHardLinkW(dst, src, ptr::mut_null()) } - } - }) + }) + })) } #[cfg(unix)] @@ -851,12 +845,12 @@ pub fn stat(p: &CString) -> IoResult<io::FileStat> { #[cfg(windows)] fn os_stat(p: &CString) -> IoResult<io::FileStat> { let mut stat: libc::stat = unsafe { intrinsics::uninit() }; - do as_utf16_p(p.as_str().unwrap()) |up| { + as_utf16_p(p.as_str().unwrap(), |up| { match unsafe { libc::wstat(up, &mut stat) } { 0 => Ok(mkstat(&stat, p)), _ => Err(super::last_error()), } - } + }) } #[cfg(unix)] @@ -898,9 +892,7 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> { modtime: (mtime / 1000) as libc::time64_t, }; unsafe { - do as_utf16_p(p.as_str().unwrap()) |p| { - libc::wutime(p, &buf) - } + as_utf16_p(p.as_str().unwrap(), |p| libc::wutime(p, &buf)) } } diff --git a/src/libstd/io/native/process.rs b/src/libstd/io/native/process.rs index 6f726d1a45e..ef531c8803c 100644 --- a/src/libstd/io/native/process.rs +++ b/src/libstd/io/native/process.rs @@ -234,18 +234,18 @@ fn spawn_process_os(prog: &str, args: &[~str], let mut pi = zeroed_process_information(); let mut create_err = None; - do with_envp(env) |envp| { - do with_dirp(dir) |dirp| { - do cmd.with_c_str |cmdp| { + with_envp(env, |envp| { + with_dirp(dir, |dirp| { + cmd.with_c_str(|cmdp| { let created = CreateProcessA(ptr::null(), cast::transmute(cmdp), ptr::mut_null(), ptr::mut_null(), TRUE, 0, envp, dirp, &mut si, &mut pi); if created == FALSE { create_err = Some(os::last_os_error()); } - } - } - } + }) + }) + }); CloseHandle(si.hStdInput); CloseHandle(si.hStdOutput); @@ -411,22 +411,22 @@ fn spawn_process_os(prog: &str, args: &[~str], close(fd as c_int); } - do with_dirp(dir) |dirp| { + with_dirp(dir, |dirp| { if !dirp.is_null() && chdir(dirp) == -1 { fail!("failure in chdir: {}", os::last_os_error()); } - } + }); - do with_envp(env) |envp| { + with_envp(env, |envp| { if !envp.is_null() { set_environ(envp); } - do with_argv(prog, args) |argv| { + with_argv(prog, args, |argv| { execvp(*argv, argv); // execvp only returns if an error occurred fail!("failure in execvp: {}", os::last_os_error()); - } - } + }) + }) } } @@ -448,9 +448,7 @@ fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T { // Next, convert each of the byte strings into a pointer. This is // technically unsafe as the caller could leak these pointers out of our // scope. - let mut ptrs = do tmps.map |tmp| { - tmp.with_ref(|buf| buf) - }; + let mut ptrs = tmps.map(|tmp| tmp.with_ref(|buf| buf)); // Finally, make sure we add a null pointer. ptrs.push(ptr::null()); @@ -475,14 +473,10 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*c_void| -> T) -> T { } // Once again, this is unsafe. - let mut ptrs = do tmps.map |tmp| { - tmp.with_ref(|buf| buf) - }; + let mut ptrs = tmps.map(|tmp| tmp.with_ref(|buf| buf)); ptrs.push(ptr::null()); - do ptrs.as_imm_buf |buf, _| { - unsafe { cb(cast::transmute(buf)) } - } + ptrs.as_imm_buf(|buf, _| unsafe { cb(cast::transmute(buf)) }) } _ => cb(ptr::null()) } @@ -505,9 +499,7 @@ fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*mut c_void| -> T) -> T { blk.push(0); - do blk.as_imm_buf |p, _len| { - unsafe { cb(cast::transmute(p)) } - } + blk.as_imm_buf(|p, _len| unsafe { cb(cast::transmute(p)) }); } _ => cb(ptr::mut_null()) } diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index 7e2d1fc5e83..03af64cc6dc 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -97,7 +97,7 @@ pub fn get_host_addresses(host: &str) -> Option<~[IpAddr]> { /// consumption just yet. fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>) -> Option<~[Info]> { - do with_local_io |io| { + with_local_io(|io| { match io.get_host_addresses(hostname, servname, hint) { Ok(i) => Some(i), Err(ioerr) => { @@ -105,7 +105,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, None } } - } + }) } #[cfg(test)] diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 32c732b4fda..e089628b9c7 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -94,9 +94,7 @@ impl<'self> Parser<'self> { // Commit only if parser read till EOF fn read_till_eof<T>(&mut self, cb: |&mut Parser| -> Option<T>) -> Option<T> { - do self.read_atomically |p| { - cb(p).filtered(|_| p.is_eof()) - } + self.read_atomically(|p| cb(p).filtered(|_| p.is_eof())) } // Return result of first successful parser @@ -120,7 +118,7 @@ impl<'self> Parser<'self> { pb: |&mut Parser| -> Option<B>, pc: |&mut Parser| -> Option<C>) -> Option<(A, B, C)> { - do self.read_atomically |p| { + self.read_atomically(|p| { let a = pa(p); let b = if a.is_some() { pb(p) } else { None }; let c = if b.is_some() { pc(p) } else { None }; @@ -128,7 +126,7 @@ impl<'self> Parser<'self> { (Some(a), Some(b), Some(c)) => Some((a, b, c)), _ => None } - } + }) } // Read next char @@ -144,9 +142,9 @@ impl<'self> Parser<'self> { // Return char and advance iff next char is equal to requested fn read_given_char(&mut self, c: char) -> Option<char> { - do self.read_atomically |p| { + self.read_atomically(|p| { p.read_char().filtered(|&next| next == c) - } + }) } // Read digit @@ -165,9 +163,9 @@ impl<'self> Parser<'self> { } } - do self.read_atomically |p| { + self.read_atomically(|p| { p.read_char().and_then(|c| parse_digit(c, radix)) - } + }) } fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> { @@ -195,9 +193,7 @@ impl<'self> Parser<'self> { // Read number, failing if max_digits of number value exceeded fn read_number(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> { - do self.read_atomically |p| { - p.read_number_impl(radix, max_digits, upto) - } + self.read_atomically(|p| p.read_number_impl(radix, max_digits, upto)) } fn read_ipv4_addr_impl(&mut self) -> Option<IpAddr> { @@ -220,9 +216,7 @@ impl<'self> Parser<'self> { // Read IPv4 address fn read_ipv4_addr(&mut self) -> Option<IpAddr> { - do self.read_atomically |p| { - p.read_ipv4_addr_impl() - } + self.read_atomically(|p| p.read_ipv4_addr_impl()) } fn read_ipv6_addr_impl(&mut self) -> Option<IpAddr> { @@ -238,13 +232,13 @@ impl<'self> Parser<'self> { let mut i = 0; while i < limit { if i < limit - 1 { - let ipv4 = do p.read_atomically |p| { + let ipv4 = p.read_atomically(|p| { if i == 0 || p.read_given_char(':').is_some() { p.read_ipv4_addr() } else { None } - }; + }); match ipv4 { Some(Ipv4Addr(a, b, c, d)) => { groups[i + 0] = (a as u16 << 8) | (b as u16); @@ -255,13 +249,13 @@ impl<'self> Parser<'self> { } } - let group = do p.read_atomically |p| { + let group = p.read_atomically(|p| { if i == 0 || p.read_given_char(':').is_some() { p.read_number(16, 4, 0x10000).map(|n| n as u16) } else { None } - }; + }); match group { Some(g) => groups[i] = g, None => return (i, false) @@ -296,9 +290,7 @@ impl<'self> Parser<'self> { } fn read_ipv6_addr(&mut self) -> Option<IpAddr> { - do self.read_atomically |p| { - p.read_ipv6_addr_impl() - } + self.read_atomically(|p| p.read_ipv6_addr_impl()) } fn read_ip_addr(&mut self) -> Option<IpAddr> { @@ -330,17 +322,13 @@ impl<'self> Parser<'self> { impl FromStr for IpAddr { fn from_str(s: &str) -> Option<IpAddr> { - do Parser::new(s).read_till_eof |p| { - p.read_ip_addr() - } + Parser::new(s).read_till_eof(|p| p.read_ip_addr()) } } impl FromStr for SocketAddr { fn from_str(s: &str) -> Option<SocketAddr> { - do Parser::new(s).read_till_eof |p| { - p.read_socket_addr() - } + Parser::new(s).read_till_eof(|p| p.read_socket_addr()) } } diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index a59d652d739..ac099e67f79 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -26,7 +26,7 @@ impl TcpStream { } pub fn connect(addr: SocketAddr) -> Option<TcpStream> { - do with_local_io |io| { + with_local_io(|io| { match io.tcp_connect(addr) { Ok(s) => Some(TcpStream::new(s)), Err(ioerr) => { @@ -34,7 +34,7 @@ impl TcpStream { None } } - } + }) } pub fn peer_name(&mut self) -> Option<SocketAddr> { @@ -92,7 +92,7 @@ pub struct TcpListener { impl TcpListener { pub fn bind(addr: SocketAddr) -> Option<TcpListener> { - do with_local_io |io| { + with_local_io(|io| { match io.tcp_bind(addr) { Ok(l) => Some(TcpListener { obj: l }), Err(ioerr) => { @@ -100,7 +100,7 @@ impl TcpListener { None } } - } + }) } pub fn socket_name(&mut self) -> Option<SocketAddr> { diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index b8cdbfc25cb..38def44d9d0 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -21,7 +21,7 @@ pub struct UdpSocket { impl UdpSocket { pub fn bind(addr: SocketAddr) -> Option<UdpSocket> { - do with_local_io |io| { + with_local_io(|io| { match io.udp_bind(addr) { Ok(s) => Some(UdpSocket { obj: s }), Err(ioerr) => { @@ -29,7 +29,7 @@ impl UdpSocket { None } } - } + }) } pub fn recvfrom(&mut self, buf: &mut [u8]) -> Option<(uint, SocketAddr)> { @@ -84,13 +84,13 @@ impl UdpStream { impl Reader for UdpStream { fn read(&mut self, buf: &mut [u8]) -> Option<uint> { let peer = self.connectedTo; - do self.as_socket |sock| { + self.as_socket(|sock| { match sock.recvfrom(buf) { Some((_nread, src)) if src != peer => Some(0), Some((nread, _src)) => Some(nread), None => None, } - } + }) } fn eof(&mut self) -> bool { fail!() } @@ -98,9 +98,7 @@ impl Reader for UdpStream { impl Writer for UdpStream { fn write(&mut self, buf: &[u8]) { - do self.as_socket |sock| { - sock.sendto(buf, self.connectedTo); - } + self.as_socket(|sock| sock.sendto(buf, self.connectedTo)); } } diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs index 438261ba8a0..eb86f0ef97f 100644 --- a/src/libstd/io/net/unix.rs +++ b/src/libstd/io/net/unix.rs @@ -59,7 +59,7 @@ impl UnixStream { /// stream.write([1, 2, 3]); /// pub fn connect<P: ToCStr>(path: &P) -> Option<UnixStream> { - do with_local_io |io| { + with_local_io(|io| { match io.unix_connect(&path.to_c_str()) { Ok(s) => Some(UnixStream::new(s)), Err(ioerr) => { @@ -67,7 +67,7 @@ impl UnixStream { None } } - } + }) } } @@ -108,7 +108,7 @@ impl UnixListener { /// } /// pub fn bind<P: ToCStr>(path: &P) -> Option<UnixListener> { - do with_local_io |io| { + with_local_io(|io| { match io.unix_bind(&path.to_c_str()) { Ok(s) => Some(UnixListener{ obj: s }), Err(ioerr) => { @@ -116,7 +116,7 @@ impl UnixListener { None } } - } + }) } } diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs index edbc6fa4285..373de1649ed 100644 --- a/src/libstd/io/pipe.rs +++ b/src/libstd/io/pipe.rs @@ -44,7 +44,7 @@ impl PipeStream { /// If the pipe cannot be created, an error will be raised on the /// `io_error` condition. pub fn open(fd: file::fd_t) -> Option<PipeStream> { - do with_local_io |io| { + with_local_io(|io| { match io.pipe_open(fd) { Ok(obj) => Some(PipeStream { obj: obj }), Err(e) => { @@ -52,7 +52,7 @@ impl PipeStream { None } } - } + }) } pub fn new(inner: ~RtioPipe) -> PipeStream { diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index 276f5369cf5..308e969c43a 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -121,7 +121,7 @@ impl Process { /// source/destination pub fn new(config: ProcessConfig) -> Option<Process> { let config = Cell::new(config); - do with_local_io |io| { + with_local_io(|io| { match io.spawn(config.take()) { Ok((p, io)) => Some(Process{ handle: p, @@ -134,7 +134,7 @@ impl Process { None } } - } + }) } /// Returns the process id of this child process diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index 1310152d05f..f6e79a03323 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -123,7 +123,7 @@ impl Listener { if self.handles.contains_key(&signum) { return true; // self is already listening to signum, so succeed } - do with_local_io |io| { + with_local_io(|io| { match io.signal(signum, self.chan.clone()) { Ok(w) => { self.handles.insert(signum, w); @@ -134,7 +134,7 @@ impl Listener { None } } - }.is_some() + }).is_some() } /// Unregisters a signal. If this listener currently had a handler @@ -212,13 +212,13 @@ mod test { use super::User1; let mut s = Listener::new(); let mut called = false; - do io::io_error::cond.trap(|_| { + io::io_error::cond.trap(|_| { called = true; - }).inside { + }).inside(|| { if s.register(User1) { fail!("Unexpected successful registry of signum {:?}", User1); } - } + }); assert!(called); } } diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index 1362d702f1c..2aa8b0c7ed6 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -70,7 +70,7 @@ enum StdSource { } fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T { - do with_local_io |io| { + with_local_io(|io| { let fd = unsafe { libc::dup(fd) }; match io.tty_open(fd, readable) { Ok(tty) => Some(f(TTY(tty))), @@ -84,14 +84,14 @@ fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T { Some(f(File(io.fs_from_raw_fd(fd, CloseAsynchronously)))) } } - }.unwrap() + }).unwrap() } /// Creates a new non-blocking handle to the stdin of the current process. /// /// See `stdout()` for notes about this function. pub fn stdin() -> StdReader { - do src(libc::STDIN_FILENO, true) |src| { StdReader { inner: src } } + src(libc::STDIN_FILENO, true, |src| StdReader { inner: src }) } /// Creates a new non-blocking handle to the stdout of the current process. @@ -101,14 +101,14 @@ pub fn stdin() -> StdReader { /// task context because the stream returned will be a non-blocking object using /// the local scheduler to perform the I/O. pub fn stdout() -> StdWriter { - do src(libc::STDOUT_FILENO, false) |src| { StdWriter { inner: src } } + src(libc::STDOUT_FILENO, false, |src| StdWriter { inner: src }) } /// Creates a new non-blocking handle to the stderr of the current process. /// /// See `stdout()` for notes about this function. pub fn stderr() -> StdWriter { - do src(libc::STDERR_FILENO, false) |src| { StdWriter { inner: src } } + src(libc::STDERR_FILENO, false, |src| StdWriter { inner: src }) } // Helper to access the local task's stdout handle @@ -116,11 +116,11 @@ pub fn stderr() -> StdWriter { // Note that this is not a safe function to expose because you can create an // aliased pointer very easily: // -// do with_task_stdout |io1| { -// do with_task_stdout |io2| { +// with_task_stdout(|io1| { +// with_task_stdout(|io2| { // // io1 aliases io2 -// } -// } +// }) +// }) fn with_task_stdout(f: |&mut Writer|) { use rt::local::Local; use rt::task::Task; @@ -158,42 +158,34 @@ fn with_task_stdout(f: |&mut Writer|) { /// will emit output to stderr, and while they are line buffered the log /// messages are always terminated in a newline (no need to flush). pub fn flush() { - do with_task_stdout |io| { - io.flush(); - } + with_task_stdout(|io| io.flush()) } /// Prints a string to the stdout of the current process. No newline is emitted /// after the string is printed. pub fn print(s: &str) { - do with_task_stdout |io| { - io.write(s.as_bytes()); - } + with_task_stdout(|io| io.write(s.as_bytes())) } /// Prints a string as a line. to the stdout of the current process. A literal /// `\n` character is printed to the console after the string. pub fn println(s: &str) { - do with_task_stdout |io| { + with_task_stdout(|io| { io.write(s.as_bytes()); io.write(['\n' as u8]); - } + }) } /// Similar to `print`, but takes a `fmt::Arguments` structure to be compatible /// with the `format_args!` macro. pub fn print_args(fmt: &fmt::Arguments) { - do with_task_stdout |io| { - fmt::write(io, fmt); - } + with_task_stdout(|io| fmt::write(io, fmt)) } /// Similar to `println`, but takes a `fmt::Arguments` structure to be /// compatible with the `format_args!` macro. pub fn println_args(fmt: &fmt::Arguments) { - do with_task_stdout |io| { - fmt::writeln(io, fmt); - } + with_task_stdout(|io| fmt::writeln(io, fmt)) } /// Representation of a reader of a standard input stream diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs index 219f63026d2..8dda7935888 100644 --- a/src/libstd/io/timer.rs +++ b/src/libstd/io/timer.rs @@ -60,7 +60,7 @@ impl Timer { /// for a number of milliseconds, or to possibly create channels which will /// get notified after an amount of time has passed. pub fn new() -> Option<Timer> { - do with_local_io |io| { + with_local_io(|io| { match io.timer_init() { Ok(t) => Some(Timer { obj: t }), Err(ioerr) => { @@ -70,7 +70,7 @@ impl Timer { } } - } + }) } /// Blocks the current task for `msecs` milliseconds. diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 083de15008a..89907c7434c 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -189,7 +189,7 @@ pub fn get<T: 'static, U>(key: Key<T>, f: |Option<&T>| -> U) -> U { /// on loan via this or the `get` methods. This is similar to how it's a runtime /// error to take two mutable loans on an `@mut` box. pub fn get_mut<T: 'static, U>(key: Key<T>, f: |Option<&mut T>| -> U) -> U { - do get_with(key, MutLoan) |x| { + get_with(key, MutLoan, |x| { match x { None => f(None), // We're violating a lot of compiler guarantees with this @@ -199,7 +199,7 @@ pub fn get_mut<T: 'static, U>(key: Key<T>, f: |Option<&mut T>| -> U) -> U { // there is no need to be upset! Some(x) => { f(Some(unsafe { cast::transmute_mut(x) })) } } - } + }) } fn get_with<T:'static, diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 9141e87bd72..fc56bf91c2a 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -420,10 +420,10 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { // base 2 number, and then we need another for a possible '-' character. let mut buf = [0u8, ..65]; let mut cur = 0; - do strconv::int_to_str_bytes_common(n, radix, strconv::SignNeg) |i| { + strconv::int_to_str_bytes_common(n, radix, strconv::SignNeg, |i| { buf[cur] = i; cur += 1; - } + }); f(buf.slice(0, cur)) } @@ -440,9 +440,9 @@ impl ToStrRadix for $T { #[inline] fn to_str_radix(&self, radix: uint) -> ~str { let mut buf: ~[u8] = ~[]; - do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNeg) |i| { + strconv::int_to_str_bytes_common(*self, radix, strconv::SignNeg, |i| { buf.push(i); - } + }); // We know we generated valid utf-8, so we don't need to go through that // check. unsafe { str::raw::from_utf8_owned(buf) } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 49f270369f7..3c276378df8 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -271,10 +271,10 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { // base 2 number. let mut buf = [0u8, ..64]; let mut cur = 0; - do strconv::int_to_str_bytes_common(n, radix, strconv::SignNone) |i| { + strconv::int_to_str_bytes_common(n, radix, strconv::SignNone, |i| { buf[cur] = i; cur += 1; - } + }); f(buf.slice(0, cur)) } @@ -291,9 +291,9 @@ impl ToStrRadix for $T { #[inline] fn to_str_radix(&self, radix: uint) -> ~str { let mut buf = ~[]; - do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNone) |i| { + strconv::int_to_str_bytes_common(*self, radix, strconv::SignNone, |i| { buf.push(i); - } + }); // We know we generated valid utf-8, so we don't need to go through that // check. unsafe { str::raw::from_utf8_owned(buf) } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index f4576499652..baa4423220c 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -58,7 +58,7 @@ static BUF_BYTES : uint = 2048u; #[cfg(unix)] pub fn getcwd() -> Path { let mut buf = [0 as libc::c_char, ..BUF_BYTES]; - do buf.as_mut_buf |buf, len| { + buf.as_mut_buf(|buf, len| { unsafe { if libc::getcwd(buf, len as size_t).is_null() { fail!() @@ -66,7 +66,7 @@ pub fn getcwd() -> Path { Path::new(CString::new(buf as *c_char, false)) } - } + }) } #[cfg(windows)] @@ -74,13 +74,13 @@ pub fn getcwd() -> Path { use libc::DWORD; use libc::GetCurrentDirectoryW; let mut buf = [0 as u16, ..BUF_BYTES]; - do buf.as_mut_buf |buf, len| { + buf.as_mut_buf(|buf, len| { unsafe { if libc::GetCurrentDirectoryW(len as DWORD, buf) == 0 as DWORD { fail!(); } } - } + }); Path::new(str::from_utf16(buf)) } @@ -104,7 +104,7 @@ pub mod win32 { while !done { let mut k: DWORD = 0; let mut buf = vec::from_elem(n as uint, 0u16); - do buf.as_mut_buf |b, _sz| { + buf.as_mut_buf(|b, _sz| { k = f(b, TMPBUF_SZ as DWORD); if k == (0 as DWORD) { done = true; @@ -115,7 +115,7 @@ pub mod win32 { } else { done = true; } - } + }); if k != 0 && done { let sub = buf.slice(0, k as uint); res = option::Some(str::from_utf16(sub)); @@ -144,12 +144,10 @@ fn with_env_lock<T>(f: || -> T) -> T { static mut lock: Mutex = MUTEX_INIT; unsafe { - return do (|| { + return (|| { lock.lock(); f() - }).finally { - lock.unlock(); - }; + }).finally(|| lock.unlock()); } } @@ -172,9 +170,9 @@ pub fn env() -> ~[(~str,~str)] { os::last_os_error()); } let mut result = ~[]; - do c_str::from_c_multistring(ch as *libc::c_char, None) |cstr| { + c_str::from_c_multistring(ch as *libc::c_char, None, |cstr| { result.push(cstr.as_str().unwrap().to_owned()); - }; + }); FreeEnvironmentStringsA(ch); result } @@ -207,10 +205,10 @@ pub fn env() -> ~[(~str,~str)] { } pairs } - do with_env_lock { + with_env_lock(|| { let unparsed_environ = get_env_pairs(); env_convert(unparsed_environ) - } + }) } } @@ -219,16 +217,14 @@ pub fn env() -> ~[(~str,~str)] { /// None if the variable isn't set. pub fn getenv(n: &str) -> Option<~str> { unsafe { - do with_env_lock { - let s = do n.with_c_str |buf| { - libc::getenv(buf) - }; + with_env_lock(|| { + let s = n.with_c_str(|buf| libc::getenv(buf)); if s.is_null() { None } else { Some(str::raw::from_c_str(s)) } - } + }) } } @@ -237,14 +233,14 @@ pub fn getenv(n: &str) -> Option<~str> { /// None if the variable isn't set. pub fn getenv(n: &str) -> Option<~str> { unsafe { - do with_env_lock { + with_env_lock(|| { use os::win32::{as_utf16_p, fill_utf16_buf_and_decode}; - do as_utf16_p(n) |u| { - do fill_utf16_buf_and_decode() |buf, sz| { + as_utf16_p(n, |u| { + fill_utf16_buf_and_decode(|buf, sz| { libc::GetEnvironmentVariableW(u, buf, sz) - } - } - } + }) + }) + }) } } @@ -254,13 +250,13 @@ pub fn getenv(n: &str) -> Option<~str> { /// process pub fn setenv(n: &str, v: &str) { unsafe { - do with_env_lock { - do n.with_c_str |nbuf| { - do v.with_c_str |vbuf| { + with_env_lock(|| { + n.with_c_str(|nbuf| { + v.with_c_str(|vbuf| { libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1); - } - } - } + }) + }) + }) } } @@ -270,14 +266,14 @@ pub fn setenv(n: &str, v: &str) { /// process pub fn setenv(n: &str, v: &str) { unsafe { - do with_env_lock { + with_env_lock(|| { use os::win32::as_utf16_p; - do as_utf16_p(n) |nbuf| { - do as_utf16_p(v) |vbuf| { + as_utf16_p(n, |nbuf| { + as_utf16_p(v, |vbuf| { libc::SetEnvironmentVariableW(nbuf, vbuf); - } - } - } + }) + }) + }) } } @@ -286,22 +282,22 @@ pub fn unsetenv(n: &str) { #[cfg(unix)] fn _unsetenv(n: &str) { unsafe { - do with_env_lock { - do n.with_c_str |nbuf| { + with_env_lock(|| { + n.with_c_str(|nbuf| { libc::funcs::posix01::unistd::unsetenv(nbuf); - } - } + }) + }) } } #[cfg(windows)] fn _unsetenv(n: &str) { unsafe { - do with_env_lock { + with_env_lock(|| { use os::win32::as_utf16_p; - do as_utf16_p(n) |nbuf| { + as_utf16_p(n, |nbuf| { libc::SetEnvironmentVariableW(nbuf, ptr::null()); - } - } + }) + }) } } @@ -372,10 +368,10 @@ pub fn self_exe_path() -> Option<Path> { if err != 0 { return None; } if sz == 0 { return None; } let mut v: ~[u8] = vec::with_capacity(sz as uint); - let err = do v.as_mut_buf |buf,_| { + let err = v.as_mut_buf(|buf,_| { sysctl(vec::raw::to_ptr(mib), mib.len() as ::libc::c_uint, buf as *mut c_void, &mut sz, ptr::null(), 0u as size_t) - }; + }); if err != 0 { return None; } if sz == 0 { return None; } vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL @@ -403,9 +399,9 @@ pub fn self_exe_path() -> Option<Path> { _NSGetExecutablePath(ptr::mut_null(), &mut sz); if sz == 0 { return None; } let mut v: ~[u8] = vec::with_capacity(sz as uint); - let err = do v.as_mut_buf |buf,_| { + let err = v.as_mut_buf(|buf, _| { _NSGetExecutablePath(buf as *mut i8, &mut sz) - }; + }); if err != 0 { return None; } vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL Some(v) @@ -416,9 +412,9 @@ pub fn self_exe_path() -> Option<Path> { fn load_self() -> Option<~[u8]> { unsafe { use os::win32::fill_utf16_buf_and_decode; - do fill_utf16_buf_and_decode() |buf, sz| { + fill_utf16_buf_and_decode(|buf, sz| { libc::GetModuleFileNameW(0u as libc::DWORD, buf, sz) - }.map(|s| s.into_bytes()) + }).map(|s| s.into_bytes()) } } @@ -452,13 +448,13 @@ pub fn homedir() -> Option<Path> { #[cfg(windows)] fn secondary() -> Option<Path> { - do getenv("USERPROFILE").and_then |p| { + getenv("USERPROFILE").and_then(|p| { if !p.is_empty() { Path::new_opt(p) } else { None } - } + }) } } @@ -536,19 +532,19 @@ pub fn change_dir(p: &Path) -> bool { fn chdir(p: &Path) -> bool { unsafe { use os::win32::as_utf16_p; - return do as_utf16_p(p.as_str().unwrap()) |buf| { + return as_utf16_p(p.as_str().unwrap(), |buf| { libc::SetCurrentDirectoryW(buf) != (0 as libc::BOOL) - }; + }); } } #[cfg(unix)] fn chdir(p: &Path) -> bool { - do p.with_c_str |buf| { + p.with_c_str(|buf| { unsafe { libc::chdir(buf) == (0 as c_int) } - } + }) } } @@ -637,7 +633,7 @@ pub fn last_os_error() -> ~str { let mut buf = [0 as c_char, ..TMPBUF_SZ]; - do buf.as_mut_buf |buf, len| { + buf.as_mut_buf(|buf, len| { unsafe { if strerror_r(errno() as c_int, buf, len as size_t) < 0 { fail!("strerror_r failure"); @@ -645,7 +641,7 @@ pub fn last_os_error() -> ~str { str::raw::from_c_str(buf as *c_char) } - } + }) } #[cfg(windows)] @@ -678,7 +674,7 @@ pub fn last_os_error() -> ~str { let mut buf = [0 as WCHAR, ..TMPBUF_SZ]; unsafe { - do buf.as_mut_buf |buf, len| { + buf.as_mut_buf(|buf, len| { let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, ptr::mut_null(), @@ -690,7 +686,7 @@ pub fn last_os_error() -> ~str { if res == 0 { fail!("[{}] FormatMessage failure", errno()); } - } + }); str::from_utf16(buf) } @@ -1466,13 +1462,11 @@ mod tests { let size = MemoryMap::granularity() * 2; let fd = unsafe { - let fd = do path.with_c_str |path| { + let fd = path.with_c_str(|path| { open(path, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR) - }; + }); lseek_(fd, size); - do "x".with_c_str |x| { - assert!(write(fd, x as *c_void, 1) == 1); - } + "x".with_c_str(|x| assert!(write(fd, x as *c_void, 1) == 1)); fd }; let chunk = match MemoryMap::new(size / 2, [ @@ -1491,7 +1485,7 @@ mod tests { assert!(*chunk.data == 0xbe); close(fd); } - do io::ignore_io_error { fs::unlink(&path); } + io::ignore_io_error(|| fs::unlink(&path)); } // More recursive_mkdir tests are in extra::tempfile diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index f58db55d4c5..2b6009206ac 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -530,9 +530,7 @@ pub struct Display<'self, P> { impl<'self, P: GenericPath> fmt::Default for Display<'self, P> { fn fmt(d: &Display<P>, f: &mut fmt::Formatter) { - do d.with_str |s| { - f.pad(s) - } + d.with_str(|s| f.pad(s)) } } diff --git a/src/libstd/rand/isaac.rs b/src/libstd/rand/isaac.rs index 42254b211a1..877df1fb644 100644 --- a/src/libstd/rand/isaac.rs +++ b/src/libstd/rand/isaac.rs @@ -51,9 +51,9 @@ impl IsaacRng { unsafe { let ptr = raw::to_mut_ptr(rng.rsl); - do raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl)) |slice| { + raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl), |slice| { OSRng::new().fill_bytes(slice); - } + }) } rng.init(true); @@ -94,7 +94,7 @@ impl IsaacRng { }} ); - do 4.times { mix!(); } + 4.times(|| mix!()); if use_rsl { macro_rules! memloop ( @@ -256,9 +256,9 @@ impl Isaac64Rng { unsafe { let ptr = raw::to_mut_ptr(rng.rsl); - do raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl)) |slice| { + raw::mut_buf_as_slice(ptr as *mut u8, mem::size_of_val(&rng.rsl), |slice| { OSRng::new().fill_bytes(slice); - } + }) } rng.init(true); diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs index 1b1546e57a3..9506a772ee8 100644 --- a/src/libstd/rc.rs +++ b/src/libstd/rc.rs @@ -168,6 +168,28 @@ impl<T> Drop for Rc<T> { } } +impl<T> Clone for RcMut<T> { + /// Return a shallow copy of the reference counted pointer. + #[inline] + fn clone(&self) -> RcMut<T> { + unsafe { + (*self.ptr).count += 1; + RcMut{ptr: self.ptr} + } + } +} + +impl<T: DeepClone> DeepClone for RcMut<T> { + /// Return a deep copy of the reference counted pointer. + #[inline] + fn deep_clone(&self) -> RcMut<T> { + self.with_borrow(|x| { + // FIXME: #6497: should avoid freeze (slow) + unsafe { RcMut::new_unchecked(x.deep_clone()) } + }) + } +} + #[cfg(test)] mod test_rc { use super::*; @@ -177,9 +199,9 @@ mod test_rc { fn test_clone() { let x = Rc::from_send(RefCell::new(5)); let y = x.clone(); - do x.borrow().with_mut |inner| { + x.borrow().with_mut(|inner| { *inner = 20; - } + }); assert_eq!(y.borrow().with(|v| *v), 20); } @@ -187,9 +209,9 @@ mod test_rc { fn test_deep_clone() { let x = Rc::from_send(RefCell::new(5)); let y = x.deep_clone(); - do x.borrow().with_mut |inner| { + x.borrow().with_mut(|inner| { *inner = 20; - } + }); assert_eq!(y.borrow().with(|v| *v), 5); } diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index d0a69649176..8a3e60eb3e2 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -50,16 +50,12 @@ pub fn MovePtrAdaptor<V:TyVisitor + MovePtr>(v: V) -> MovePtrAdaptor<V> { impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> { #[inline] pub fn bump(&mut self, sz: uint) { - do self.inner.move_ptr() |p| { - ((p as uint) + sz) as *c_void - }; + self.inner.move_ptr(|p| ((p as uint) + sz) as *c_void) } #[inline] pub fn align(&mut self, a: uint) { - do self.inner.move_ptr() |p| { - align(p as uint, a) as *c_void - }; + self.inner.move_ptr(|p| align(p as uint, a) as *c_void) } #[inline] diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index d30d0887066..d26989c36e6 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -53,18 +53,18 @@ impl Repr for bool { impl Repr for int { fn write_repr(&self, writer: &mut io::Writer) { - do ::int::to_str_bytes(*self, 10u) |bits| { + ::int::to_str_bytes(*self, 10u, |bits| { writer.write(bits); - } + }) } } macro_rules! int_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty { fn write_repr(&self, writer: &mut io::Writer) { - do ::$ty::to_str_bytes(*self, 10u) |bits| { + ::$ty::to_str_bytes(*self, 10u, |bits| { writer.write(bits); writer.write(bytes!($suffix)); - } + }) } })) @@ -163,9 +163,9 @@ impl<'self> ReprVisitor<'self> { #[inline] pub fn write<T:Repr>(&mut self) -> bool { - do self.get |this, v:&T| { + self.get(|this, v:&T| { v.write_repr(unsafe { ::cast::transmute_copy(&this.writer) }); - } + }) } pub fn write_escaped_slice(&mut self, slice: &str) { @@ -234,9 +234,9 @@ impl<'self> ReprVisitor<'self> { } '\x20'..'\x7e' => self.writer.write([ch as u8]), _ => { - do char::escape_unicode(ch) |c| { + char::escape_unicode(ch, |c| { self.writer.write([c as u8]); - } + }) } } } @@ -265,31 +265,29 @@ impl<'self> TyVisitor for ReprVisitor<'self> { fn visit_f64(&mut self) -> bool { self.write::<f64>() } fn visit_char(&mut self) -> bool { - do self.get::<char> |this, &ch| { + self.get::<char>(|this, &ch| { this.writer.write(['\'' as u8]); this.write_escaped_char(ch, false); this.writer.write(['\'' as u8]); - } + }) } fn visit_estr_box(&mut self) -> bool { - do self.get::<@str> |this, s| { + self.get::<@str>(|this, s| { this.writer.write(['@' as u8]); this.write_escaped_slice(*s); - } + }) } fn visit_estr_uniq(&mut self) -> bool { - do self.get::<~str> |this, s| { + self.get::<~str>(|this, s| { this.writer.write(['~' as u8]); this.write_escaped_slice(*s); - } + }) } fn visit_estr_slice(&mut self) -> bool { - do self.get::<&str> |this, s| { - this.write_escaped_slice(*s); - } + self.get::<&str>(|this, s| this.write_escaped_slice(*s)) } // Type no longer exists, vestigial function. @@ -299,91 +297,91 @@ impl<'self> TyVisitor for ReprVisitor<'self> { fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { self.writer.write(['@' as u8]); self.write_mut_qualifier(mtbl); - do self.get::<&raw::Box<()>> |this, b| { + self.get::<&raw::Box<()>>(|this, b| { let p = ptr::to_unsafe_ptr(&b.data) as *c_void; this.visit_ptr_inner(p, inner); - } + }) } fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool { self.writer.write(['~' as u8]); - do self.get::<*c_void> |this, b| { + self.get::<*c_void>(|this, b| { this.visit_ptr_inner(*b, inner); - } + }) } fn visit_uniq_managed(&mut self, _mtbl: uint, inner: *TyDesc) -> bool { self.writer.write(['~' as u8]); - do self.get::<&raw::Box<()>> |this, b| { + self.get::<&raw::Box<()>>(|this, b| { let p = ptr::to_unsafe_ptr(&b.data) as *c_void; this.visit_ptr_inner(p, inner); - } + }) } fn visit_ptr(&mut self, mtbl: uint, _inner: *TyDesc) -> bool { - do self.get::<*c_void> |this, p| { + self.get::<*c_void>(|this, p| { write!(this.writer, "({} as *", *p); this.write_mut_qualifier(mtbl); this.writer.write("())".as_bytes()); - } + }) } fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool { self.writer.write(['&' as u8]); self.write_mut_qualifier(mtbl); - do self.get::<*c_void> |this, p| { + self.get::<*c_void>(|this, p| { this.visit_ptr_inner(*p, inner); - } + }) } // Type no longer exists, vestigial function. fn visit_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { fail!(); } fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<raw::Vec<()>> |this, b| { + self.get::<raw::Vec<()>>(|this, b| { this.write_unboxed_vec_repr(mtbl, b, inner); - } + }) } fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<&raw::Box<raw::Vec<()>>> |this, b| { + self.get::<&raw::Box<raw::Vec<()>>>(|this, b| { this.writer.write(['@' as u8]); this.write_mut_qualifier(mtbl); this.write_unboxed_vec_repr(mtbl, &b.data, inner); - } + }) } fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<&raw::Vec<()>> |this, b| { + self.get::<&raw::Vec<()>>(|this, b| { this.writer.write(['~' as u8]); this.write_unboxed_vec_repr(mtbl, *b, inner); - } + }) } fn visit_evec_uniq_managed(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<&raw::Box<raw::Vec<()>>> |this, b| { + self.get::<&raw::Box<raw::Vec<()>>>(|this, b| { this.writer.write(['~' as u8]); this.write_unboxed_vec_repr(mtbl, &b.data, inner); - } + }) } fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<raw::Slice<()>> |this, s| { + self.get::<raw::Slice<()>>(|this, s| { this.writer.write(['&' as u8]); this.write_mut_qualifier(mtbl); let size = unsafe { if (*inner).size == 0 { 1 } else { (*inner).size } }; this.write_vec_range(s.data, s.len * size, inner); - } + }) } fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint, _: uint, inner: *TyDesc) -> bool { let assumed_size = if sz == 0 { n } else { sz }; - do self.get::<()> |this, b| { + self.get::<()>(|this, b| { this.write_vec_range(ptr::to_unsafe_ptr(b), assumed_size, inner); - } + }) } fn visit_enter_rec(&mut self, _n_fields: uint, @@ -600,10 +598,10 @@ impl<'self> TyVisitor for ReprVisitor<'self> { fn visit_opaque_box(&mut self) -> bool { self.writer.write(['@' as u8]); - do self.get::<&raw::Box<()>> |this, b| { + self.get::<&raw::Box<()>>(|this, b| { let p = ptr::to_unsafe_ptr(&b.data) as *c_void; this.visit_ptr_inner(p, b.type_desc); - } + }) } fn visit_closure_ptr(&mut self, _ck: uint) -> bool { true } diff --git a/src/libstd/rt/basic.rs b/src/libstd/rt/basic.rs index 2c1c5d84be1..d857f39ceaf 100644 --- a/src/libstd/rt/basic.rs +++ b/src/libstd/rt/basic.rs @@ -71,13 +71,13 @@ impl BasicLoop { fn remote_work(&mut self) { let messages = unsafe { - do self.messages.with |messages| { + self.messages.with(|messages| { if messages.len() > 0 { Some(util::replace(messages, ~[])) } else { None } - } + }) }; let messages = match messages { Some(m) => m, None => return @@ -139,11 +139,11 @@ impl EventLoop for BasicLoop { unsafe { // We block here if we have no messages to process and we may // receive a message at a later date - do self.messages.hold_and_wait |messages| { + self.messages.hold_and_wait(|messages| { self.remotes.len() > 0 && messages.len() == 0 && self.work.len() == 0 - } + }) } } } @@ -189,9 +189,9 @@ impl BasicRemote { impl RemoteCallback for BasicRemote { fn fire(&mut self) { unsafe { - do self.queue.hold_and_signal |queue| { + self.queue.hold_and_signal(|queue| { queue.push(RunRemote(self.id)); - } + }) } } } @@ -199,9 +199,9 @@ impl RemoteCallback for BasicRemote { impl Drop for BasicRemote { fn drop(&mut self) { unsafe { - do self.queue.hold_and_signal |queue| { + self.queue.hold_and_signal(|queue| { queue.push(RemoveRemote(self.id)); - } + }) } } } diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs index 2c78a32a4b6..30c2264bd86 100644 --- a/src/libstd/rt/borrowck.rs +++ b/src/libstd/rt/borrowck.rs @@ -35,9 +35,7 @@ pub struct BorrowRecord { } fn try_take_task_borrow_list() -> Option<~[BorrowRecord]> { - do Local::borrow |task: &mut Task| { - task.borrow_list.take() - } + Local::borrow(|task: &mut Task| task.borrow_list.take()) } fn swap_task_borrow_list(f: |~[BorrowRecord]| -> ~[BorrowRecord]) { @@ -47,9 +45,7 @@ fn swap_task_borrow_list(f: |~[BorrowRecord]| -> ~[BorrowRecord]) { }; let borrows = f(borrows); let borrows = Cell::new(borrows); - do Local::borrow |task: &mut Task| { - task.borrow_list = Some(borrows.take()); - } + Local::borrow(|task: &mut Task| task.borrow_list = Some(borrows.take())) } pub fn clear_task_borrow_list() { @@ -64,9 +60,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> match try_take_task_borrow_list() { None => { // not recording borrows let msg = "borrowed"; - do msg.with_c_str |msg_p| { - task::begin_unwind_raw(msg_p, file, line); - } + msg.with_c_str(|msg_p| task::begin_unwind_raw(msg_p, file, line)) } Some(borrow_list) => { // recording borrows let mut msg = ~"borrowed"; @@ -80,9 +74,7 @@ unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> sep = " and at "; } } - do msg.with_c_str |msg_p| { - task::begin_unwind_raw(msg_p, file, line) - } + msg.with_c_str(|msg_p| task::begin_unwind_raw(msg_p, file, line)) } } } @@ -158,33 +150,35 @@ pub unsafe fn record_borrow(a: *u8, old_ref_count: uint, // was not borrowed before let a = a as *mut raw::Box<()>; debug_borrow("record_borrow:", a, old_ref_count, 0, file, line); - do swap_task_borrow_list |borrow_list| { + swap_task_borrow_list(|borrow_list| { let mut borrow_list = borrow_list; borrow_list.push(BorrowRecord {box: a, file: file, line: line}); borrow_list - } + }) } } -pub unsafe fn unrecord_borrow(a: *u8, old_ref_count: uint, - file: *c_char, line: size_t) { +pub unsafe fn unrecord_borrow(a: *u8, + old_ref_count: uint, + file: *c_char, + line: size_t) { if (old_ref_count & ALL_BITS) == 0 { // was not borrowed before, so we should find the record at // the end of the list let a = a as *mut raw::Box<()>; debug_borrow("unrecord_borrow:", a, old_ref_count, 0, file, line); - do swap_task_borrow_list |borrow_list| { + swap_task_borrow_list(|borrow_list| { let mut borrow_list = borrow_list; assert!(!borrow_list.is_empty()); let br = borrow_list.pop(); if br.box != a || br.file != file || br.line != line { let err = format!("wrong borrow found, br={:?}", br); - do err.with_c_str |msg_p| { + err.with_c_str(|msg_p| { task::begin_unwind_raw(msg_p, file, line) - } + }) } borrow_list - } + }) } } diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs index 8635f9372c4..e3e425f620b 100644 --- a/src/libstd/rt/comm.rs +++ b/src/libstd/rt/comm.rs @@ -165,14 +165,14 @@ impl<T: Send> ChanOne<T> { // Port is blocked. Wake it up. let recvr = BlockedTask::cast_from_uint(task_as_state); if do_resched { - do recvr.wake().map |woken_task| { + recvr.wake().map(|woken_task| { Scheduler::run_task(woken_task); - }; + }); } else { let recvr = Cell::new(recvr); - do Local::borrow |sched: &mut Scheduler| { + Local::borrow(|sched: &mut Scheduler| { sched.enqueue_blocked_task(recvr.take()); - } + }) } } } @@ -209,9 +209,9 @@ impl<T: Send> PortOne<T> { // No data available yet. // Switch to the scheduler to put the ~Task into the Packet state. let sched: ~Scheduler = Local::take(); - do sched.deschedule_running_task_and_then |sched, task| { + sched.deschedule_running_task_and_then(|sched, task| { self.block_on(sched, task); - } + }) } // Task resumes. @@ -230,9 +230,9 @@ impl<T: Send> SelectInner for PortOne<T> { // The optimistic check is never necessary for correctness. For testing // purposes, making it randomly return false simulates a racing sender. use rand::{Rand}; - let actually_check = do Local::borrow |sched: &mut Scheduler| { + let actually_check = Local::borrow(|sched: &mut Scheduler| { Rand::rand(&mut sched.rng) - }; + }); if actually_check { unsafe { (*self.packet()).state.load(Acquire) == STATE_ONE } } else { @@ -387,9 +387,9 @@ impl<T: Send> Drop for ChanOne<T> { // The port is blocked waiting for a message we will never send. Wake it. rtassert!((*self.packet()).payload.is_none()); let recvr = BlockedTask::cast_from_uint(task_as_state); - do recvr.wake().map |woken_task| { + recvr.wake().map(|woken_task| { Scheduler::run_task(woken_task); - }; + }); } } } @@ -491,7 +491,7 @@ impl<T: Send> GenericPort<T> for Port<T> { fn try_recv(&self) -> Option<T> { let mut b = self.next.borrow_mut(); - do b.get().take().map_default(None) |pone| { + b.get().take().map_default(None, |pone| { match pone.try_recv() { Some(StreamPayload { val, next }) => { *b.get() = Some(next); @@ -499,7 +499,7 @@ impl<T: Send> GenericPort<T> for Port<T> { } None => None } - } + }) } } @@ -516,7 +516,7 @@ impl<T: Send> Peekable<T> for Port<T> { impl<'self, T: Send> SelectInner for &'self Port<T> { #[inline] fn optimistic_check(&mut self) -> bool { - do self.next.with_mut |pone| { pone.get_mut_ref().optimistic_check() } + self.next.with_mut(|pone| { pone.get_mut_ref().optimistic_check() }) } #[inline] @@ -527,7 +527,7 @@ impl<'self, T: Send> SelectInner for &'self Port<T> { #[inline] fn unblock_from(&mut self) -> bool { - do self.next.with_mut |pone| { pone.get_mut_ref().unblock_from() } + self.next.with_mut(|pone| { pone.get_mut_ref().unblock_from() }) } } @@ -871,7 +871,7 @@ mod test { #[test] fn oneshot_multi_thread_close_stress() { if util::limit_thread_creation_due_to_osx_and_valgrind() { return; } - do stress_factor().times { + stress_factor().times(|| { do run_in_newsched_task { let (port, chan) = oneshot::<int>(); let port_cell = Cell::new(port); @@ -881,13 +881,13 @@ mod test { let _chan = chan; thread.join(); } - } + }) } #[test] fn oneshot_multi_thread_send_close_stress() { if util::limit_thread_creation_due_to_osx_and_valgrind() { return; } - do stress_factor().times { + stress_factor().times(|| { do run_in_newsched_task { let (port, chan) = oneshot::<int>(); let chan_cell = Cell::new(chan); @@ -902,13 +902,13 @@ mod test { thread1.join(); thread2.join(); } - } + }) } #[test] fn oneshot_multi_thread_recv_close_stress() { if util::limit_thread_creation_due_to_osx_and_valgrind() { return; } - do stress_factor().times { + stress_factor().times(|| { do run_in_newsched_task { let (port, chan) = oneshot::<int>(); let chan_cell = Cell::new(chan); @@ -929,13 +929,13 @@ mod test { thread1.join(); thread2.join(); } - } + }) } #[test] fn oneshot_multi_thread_send_recv_stress() { if util::limit_thread_creation_due_to_osx_and_valgrind() { return; } - do stress_factor().times { + stress_factor().times(|| { do run_in_newsched_task { let (port, chan) = oneshot::<~int>(); let chan_cell = Cell::new(chan); @@ -949,13 +949,13 @@ mod test { thread1.join(); thread2.join(); } - } + }) } #[test] fn stream_send_recv_stress() { if util::limit_thread_creation_due_to_osx_and_valgrind() { return; } - do stress_factor().times { + stress_factor().times(|| { do run_in_mt_newsched_task { let (port, chan) = stream::<~int>(); @@ -984,17 +984,17 @@ mod test { }; } } - } + }) } #[test] fn recv_a_lot() { // Regression test that we don't run out of stack in scheduler context - do run_in_newsched_task { + run_in_newsched_task(|| { let (port, chan) = stream(); - do 10000.times { chan.send(()) } - do 10000.times { port.recv() } - } + 10000.times(|| { chan.send(()) }); + 10000.times(|| { port.recv() }); + }) } #[test] @@ -1004,16 +1004,16 @@ mod test { let (port, chan) = stream(); let chan = SharedChan::new(chan); let total = stress_factor() + 100; - do total.times { + total.times(|| { let chan_clone = chan.clone(); do spawntask_random { chan_clone.send(()); } - } + }); - do total.times { + total.times(|| { port.recv(); - } + }) } } @@ -1026,22 +1026,22 @@ mod test { let end_chan = SharedChan::new(end_chan); let port = SharedPort::new(port); let total = stress_factor() + 100; - do total.times { + total.times(|| { let end_chan_clone = end_chan.clone(); let port_clone = port.clone(); do spawntask_random { port_clone.recv(); end_chan_clone.send(()); } - } + }); - do total.times { + total.times(|| { chan.send(()); - } + }); - do total.times { + total.times(|| { end_port.recv(); - } + }) } } @@ -1066,29 +1066,29 @@ mod test { let send_total = 10; let recv_total = 20; do spawntask_random { - do send_total.times { + send_total.times(|| { let chan_clone = chan.clone(); do spawntask_random { chan_clone.send(()); } - } + }) } let end_chan_clone = end_chan.clone(); do spawntask_random { - do recv_total.times { + recv_total.times(|| { let port_clone = port.clone(); let end_chan_clone = end_chan_clone.clone(); do spawntask_random { let recvd = port_clone.try_recv().is_some(); end_chan_clone.send(recvd); } - } + }) } let mut recvd = 0; - do recv_total.times { + recv_total.times(|| { recvd += if end_port.recv() { 1 } else { 0 }; - } + }); assert!(recvd == send_total); } @@ -1107,7 +1107,7 @@ mod test { let pipe = megapipe(); let total = stress_factor() + 10; let mut rng = rand::rng(); - do total.times { + total.times(|| { let msgs = rng.gen_range(0u, 10); let pipe_clone = pipe.clone(); let end_chan_clone = end_chan.clone(); @@ -1121,11 +1121,11 @@ mod test { } end_chan_clone.send(()); - } + }); - do total.times { + total.times(|| { end_port.recv(); - } + }) } } @@ -1152,13 +1152,13 @@ mod test { let cs = Cell::new((cone, cstream, cshared, mp)); unsafe { - do atomically { + atomically(|| { let (cone, cstream, cshared, mp) = cs.take(); cone.send_deferred(()); cstream.send_deferred(()); cshared.send_deferred(()); mp.send_deferred(()); - } + }) } } } diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs index ac13b12c9ad..56c77ffaa0d 100644 --- a/src/libstd/rt/kill.rs +++ b/src/libstd/rt/kill.rs @@ -257,10 +257,7 @@ impl Death { /// Collect failure exit codes from children and propagate them to a parent. pub fn collect_failure(&mut self, result: UnwindResult) { let result = Cell::new(result); - - do self.on_exit.take().map |on_exit| { - on_exit(result.take()); - }; + self.on_exit.take().map(|on_exit| on_exit(result.take())); } /// Enter a possibly-nested "atomic" section of code. Just for assertions. diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs index d47dae96283..23345926543 100644 --- a/src/libstd/rt/local.rs +++ b/src/libstd/rt/local.rs @@ -34,10 +34,10 @@ impl Local for Task { let mut res: Option<T> = None; let res_ptr: *mut Option<T> = &mut res; unsafe { - do local_ptr::borrow |task| { + local_ptr::borrow(|task| { let result = f(task); *res_ptr = Some(result); - } + }) } match res { Some(r) => { r } @@ -57,10 +57,10 @@ impl Local for Task { impl Local for Scheduler { fn put(value: ~Scheduler) { let value = Cell::new(value); - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { let task = task; task.sched = Some(value.take()); - }; + }); } #[inline] fn take() -> ~Scheduler { @@ -71,15 +71,15 @@ impl Local for Scheduler { } } fn exists(_: Option<Scheduler>) -> bool { - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { match task.sched { Some(ref _task) => true, None => false } - } + }) } fn borrow<T>(f: |&mut Scheduler| -> T) -> T { - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { match task.sched { Some(~ref mut task) => { f(task) @@ -88,7 +88,7 @@ impl Local for Scheduler { rtabort!("no scheduler") } } - } + }) } unsafe fn unsafe_take() -> ~Scheduler { rtabort!("unimpl") } unsafe fn unsafe_borrow() -> *mut Scheduler { diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs index d5ec6bd3f37..a7805a9f559 100644 --- a/src/libstd/rt/local_heap.rs +++ b/src/libstd/rt/local_heap.rs @@ -302,9 +302,7 @@ pub unsafe fn local_free(ptr: *libc::c_char) { } pub fn live_allocs() -> *mut Box { - do Local::borrow |task: &mut Task| { - task.heap.live_allocs - } + Local::borrow(|task: &mut Task| task.heap.live_allocs) } #[cfg(test)] @@ -313,15 +311,11 @@ mod bench { #[bench] fn alloc_managed_small(bh: &mut BenchHarness) { - do bh.iter { - @10; - } + bh.iter(|| @10); } #[bench] fn alloc_managed_big(bh: &mut BenchHarness) { - do bh.iter { - @[10, ..1000]; - } + bh.iter(|| @[10, ..1000]); } } diff --git a/src/libstd/rt/local_ptr.rs b/src/libstd/rt/local_ptr.rs index 862ecd6499a..eb7d8ef2f5f 100644 --- a/src/libstd/rt/local_ptr.rs +++ b/src/libstd/rt/local_ptr.rs @@ -110,11 +110,7 @@ pub unsafe fn borrow<T>(f: |&mut T|) { let unsafe_ptr = cast::transmute_mut_region(&mut *value); let value_cell = Cell::new(value); - do (|| { - f(unsafe_ptr); - }).finally { - put(value_cell.take()); - } + (|| f(unsafe_ptr)).finally(|| put(value_cell.take())); } /// Borrow a mutable reference to the thread-local value diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs index 2ca47dbff59..13e18f7d9b7 100644 --- a/src/libstd/rt/logging.rs +++ b/src/libstd/rt/logging.rs @@ -142,19 +142,17 @@ fn update_log_settings(crate_map: &CrateMap, settings: ~str) { if settings.len() > 0 { if settings == ~"::help" || settings == ~"?" { rterrln!("\nCrate log map:\n"); - do iter_crate_map(crate_map) |entry| { - rterrln!(" {}", entry.name); - } + iter_crate_map(crate_map, |entry| rterrln!(" {}", entry.name)); unsafe { exit(1); } } dirs = parse_logging_spec(settings); } let mut n_matches: u32 = 0; - do iter_crate_map(crate_map) |entry| { + iter_crate_map(crate_map, |entry| { let m = update_entry(dirs, entry); n_matches += m; - } + }); if n_matches < (dirs.len() as u32) { rterrln!("warning: got {} RUST_LOG specs but only matched\n\ diff --git a/src/libstd/rt/mpmc_bounded_queue.rs b/src/libstd/rt/mpmc_bounded_queue.rs index 2f61a433983..7f607fcf12a 100644 --- a/src/libstd/rt/mpmc_bounded_queue.rs +++ b/src/libstd/rt/mpmc_bounded_queue.rs @@ -68,9 +68,9 @@ impl<T: Send> State<T> { } else { capacity }; - let buffer = do vec::from_fn(capacity) |i:uint| { + let buffer = vec::from_fn(capacity, |i:uint| { Node{sequence:AtomicUint::new(i),value:None} - }; + }); State{ pad0: [0, ..64], buffer: buffer, diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index 1caaf77bd96..519274bb131 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -236,9 +236,9 @@ impl Scheduler { // Our scheduler must be in the task before the event loop // is started. let self_sched = Cell::new(self); - do Local::borrow |stask: &mut Task| { + Local::borrow(|stask: &mut Task| { stask.sched = Some(self_sched.take()); - }; + }); (*event_loop).run(); } @@ -538,9 +538,7 @@ impl Scheduler { /// As enqueue_task, but with the possibility for the blocked task to /// already have been killed. pub fn enqueue_blocked_task(&mut self, blocked_task: BlockedTask) { - do blocked_task.wake().map |task| { - self.enqueue_task(task); - }; + blocked_task.wake().map(|task| self.enqueue_task(task)); } // * Core Context Switching Functions @@ -643,9 +641,9 @@ impl Scheduler { // * Context Swapping Helpers - Here be ugliness! pub fn resume_task_immediately(~self, task: ~Task) { - do self.change_task_context(task) |sched, stask| { + self.change_task_context(task, |sched, stask| { sched.sched_task = Some(stask); - } + }) } fn resume_task_immediately_cl(sched: ~Scheduler, @@ -686,15 +684,15 @@ impl Scheduler { f: |&mut Scheduler, BlockedTask|) { // This is where we convert the BlockedTask-taking closure into one // that takes just a Task - do self.change_task_context(next_task) |sched, task| { + self.change_task_context(next_task, |sched, task| { f(sched, BlockedTask::block(task)) - } + }) } fn switch_task(sched: ~Scheduler, task: ~Task) { - do sched.switch_running_tasks_and_then(task) |sched, last_task| { + sched.switch_running_tasks_and_then(task, |sched, last_task| { sched.enqueue_blocked_task(last_task); - }; + }); } // * Task Context Helpers @@ -705,10 +703,10 @@ impl Scheduler { // Similar to deschedule running task and then, but cannot go through // the task-blocking path. The task is already dying. let stask = self.sched_task.take_unwrap(); - do self.change_task_context(stask) |sched, mut dead_task| { + self.change_task_context(stask, |sched, mut dead_task| { let coroutine = dead_task.coroutine.take_unwrap(); coroutine.recycle(&mut sched.stack_pool); - } + }) } pub fn run_task(task: ~Task) { @@ -718,9 +716,9 @@ impl Scheduler { pub fn run_task_later(next_task: ~Task) { let next_task = Cell::new(next_task); - do Local::borrow |sched: &mut Scheduler| { + Local::borrow(|sched: &mut Scheduler| { sched.enqueue_task(next_task.take()); - }; + }); } /// Yield control to the scheduler, executing another task. This is guaranteed @@ -731,9 +729,9 @@ impl Scheduler { self.yield_check_count = reset_yield_check(&mut self.rng); // Tell the scheduler to start stealing on the next iteration self.steal_for_yield = true; - do self.deschedule_running_task_and_then |sched, task| { + self.deschedule_running_task_and_then(|sched, task| { sched.enqueue_blocked_task(task); - } + }) } pub fn maybe_yield(mut ~self) { @@ -852,9 +850,9 @@ fn new_sched_rng() -> XorShiftRng { use iter::Iterator; use rand::SeedableRng; - let fd = do "/dev/urandom".with_c_str |name| { + let fd = "/dev/urandom".with_c_str(|name| { unsafe { libc::open(name, libc::O_RDONLY, 0) } - }; + }); if fd == -1 { rtabort!("could not open /dev/urandom for reading.") } @@ -862,13 +860,13 @@ fn new_sched_rng() -> XorShiftRng { let mut seeds = [0u32, .. 4]; let size = mem::size_of_val(&seeds); loop { - let nbytes = do seeds.as_mut_buf |buf, _| { + let nbytes = seeds.as_mut_buf(|buf, _| { unsafe { libc::read(fd, buf as *mut libc::c_void, size as libc::size_t) } - }; + }); rtassert!(nbytes as uint == size); if !seeds.iter().all(|x| *x == 0) { diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index bc9496b16cd..569d96ae388 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -142,7 +142,7 @@ impl Task { -> ~Task { let f = Cell::new(f); let home = Cell::new(home); - do Local::borrow |running_task: &mut Task| { + Local::borrow(|running_task: &mut Task| { let mut sched = running_task.sched.take_unwrap(); let new_task = ~running_task.new_child_homed(&mut sched.stack_pool, stack_size, @@ -150,7 +150,7 @@ impl Task { f.take()); running_task.sched = Some(sched); new_task - } + }) } pub fn build_child(stack_size: Option<uint>, f: proc()) -> ~Task { @@ -163,7 +163,7 @@ impl Task { -> ~Task { let f = Cell::new(f); let home = Cell::new(home); - do Local::borrow |running_task: &mut Task| { + Local::borrow(|running_task: &mut Task| { let mut sched = running_task.sched.take_unwrap(); let new_task = ~Task::new_root_homed(&mut sched.stack_pool, stack_size, @@ -171,7 +171,7 @@ impl Task { f.take()); running_task.sched = Some(sched); new_task - } + }) } pub fn build_root(stack_size: Option<uint>, f: proc()) -> ~Task { @@ -280,10 +280,10 @@ impl Task { // The only try/catch block in the world. Attempt to run the task's // client-specified code and catch any failures. - do self.unwinder.try { + self.unwinder.try(|| { // Run the task main function, then do some cleanup. - do f.finally { + f.finally(|| { // First, destroy task-local storage. This may run user dtors. // @@ -320,8 +320,8 @@ impl Task { None => {} } self.logger.take(); - } - } + }) + }); // Cleanup the dynamic borrowck debugging info borrowck::clear_task_borrow_list(); @@ -364,7 +364,7 @@ impl Task { // Grab both the scheduler and the task from TLS and check if the // task is executing on an appropriate scheduler. pub fn on_appropriate_sched() -> bool { - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { let sched_id = task.sched.get_ref().sched_id(); let sched_run_anything = task.sched.get_ref().run_anything; match task.task_type { @@ -383,7 +383,7 @@ impl Task { rtabort!("type error: expected: GreenTask, found: SchedTask"); } } - } + }) } } @@ -431,9 +431,9 @@ impl Coroutine { unsafe { // Again - might work while safe, or it might not. - do Local::borrow |sched: &mut Scheduler| { + Local::borrow(|sched: &mut Scheduler| { sched.run_cleanup_job(); - } + }); // To call the run method on a task we need a direct // reference to it. The task is in TLS, so we can @@ -442,7 +442,7 @@ impl Coroutine { // need to unsafe_borrow. let task: *mut Task = Local::unsafe_borrow(); - do (*task).run { + (*task).run(|| { // N.B. Removing `start` from the start wrapper // closure by emptying a cell is critical for // correctness. The ~Task pointer, and in turn the @@ -455,7 +455,7 @@ impl Coroutine { // scope while the task is still running. let start = start_cell.take(); start(); - }; + }); } // We remove the sched from the Task in TLS right now. @@ -584,7 +584,7 @@ pub extern "C" fn rust_stack_exhausted() { // #2361 - possible implementation of not using landing pads if in_green_task_context() { - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { let n = task.name.as_ref().map(|n| n.as_slice()).unwrap_or("<unnamed>"); // See the message below for why this is not emitted to the @@ -593,7 +593,7 @@ pub extern "C" fn rust_stack_exhausted() { // call would happen to initialized it (calling out to libuv), // and the FFI call needs 2MB of stack when we just ran out. rterrln!("task '{}' has overflowed its stack", n); - } + }) } else { rterrln!("stack overflow in non-task context"); } diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs index 16fd3fa38ea..360764daf15 100644 --- a/src/libstd/rt/tube.rs +++ b/src/libstd/rt/tube.rs @@ -68,9 +68,9 @@ impl<T> Tube<T> { assert!(self.p.refcount() > 1); // There better be somebody to wake us up assert!((*state).blocked_task.is_none()); let sched: ~Scheduler = Local::take(); - do sched.deschedule_running_task_and_then |_, task| { + sched.deschedule_running_task_and_then(|_, task| { (*state).blocked_task = Some(task); - } + }); rtdebug!("waking after tube recv"); let buf = &mut (*state).buf; assert!(!buf.is_empty()); diff --git a/src/libstd/rt/work_queue.rs b/src/libstd/rt/work_queue.rs index 24792f3904e..02ea8ab4f50 100644 --- a/src/libstd/rt/work_queue.rs +++ b/src/libstd/rt/work_queue.rs @@ -37,25 +37,25 @@ impl<T: Send> WorkQueue<T> { pub fn pop(&mut self) -> Option<T> { unsafe { - do self.queue.with |q| { + self.queue.with(|q| { if !q.is_empty() { Some(q.shift()) } else { None } - } + }) } } pub fn steal(&mut self) -> Option<T> { unsafe { - do self.queue.with |q| { + self.queue.with(|q| { if !q.is_empty() { Some(q.pop()) } else { None } - } + }) } } diff --git a/src/libstd/run.rs b/src/libstd/run.rs index 5b3ba1e6f97..7f977fdd2a3 100644 --- a/src/libstd/run.rs +++ b/src/libstd/run.rs @@ -221,20 +221,20 @@ impl Process { let ch_clone = ch.clone(); do spawn { - do io::ignore_io_error { + io::ignore_io_error(|| { match error.take() { Some(ref mut e) => ch.send((2, e.read_to_end())), None => ch.send((2, ~[])) } - } + }) } do spawn { - do io::ignore_io_error { + io::ignore_io_error(|| { match output.take() { Some(ref mut e) => ch_clone.send((1, e.read_to_end())), None => ch_clone.send((1, ~[])) } - } + }) } let status = self.finish(); diff --git a/src/libstd/select.rs b/src/libstd/select.rs index 25f8c5a2875..b619085e201 100644 --- a/src/libstd/select.rs +++ b/src/libstd/select.rs @@ -59,10 +59,10 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint { let p = Cell::new(p); let c = Cell::new(c); - do (|| { + (|| { let c = Cell::new(c.take()); let sched: ~Scheduler = Local::take(); - do sched.deschedule_running_task_and_then |sched, task| { + sched.deschedule_running_task_and_then(|sched, task| { let task_handles = task.make_selectable(ports.len()); for (index, (port, task_handle)) in @@ -77,12 +77,12 @@ pub fn select<A: Select>(ports: &mut [A]) -> uint { let c = Cell::new(c.take()); do sched.event_loop.callback { c.take().send_deferred(()) } } - }).finally { + }).finally(|| { // Unkillable is necessary not because getting killed is dangerous here, // but to force the recv not to use the same kill-flag that we used for // selecting. Otherwise a user-sender could spuriously wakeup us here. p.take().recv(); - } + }); // Task resumes. Now unblock ourselves from all the ports we blocked on. // If the success index wasn't reset, 'take' will just take all of them. diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 11f552e73ae..b2ded6ab754 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -410,11 +410,11 @@ impl<'self> Iterator<(uint, char)> for CharOffsetIterator<'self> { fn next(&mut self) -> Option<(uint, char)> { // Compute the byte offset by using the pointer offset between // the original string slice and the iterator's remaining part - let offset = do self.string.as_imm_buf |a, _| { - do self.iter.string.as_imm_buf |b, _| { + let offset = self.string.as_imm_buf(|a, _| { + self.iter.string.as_imm_buf(|b, _| { b as uint - a as uint - } - }; + }) + }); self.iter.next().map(|ch| (offset, ch)) } @@ -428,11 +428,11 @@ impl<'self> DoubleEndedIterator<(uint, char)> for CharOffsetIterator<'self> { #[inline] fn next_back(&mut self) -> Option<(uint, char)> { self.iter.next_back().map(|ch| { - let offset = do self.string.as_imm_buf |a, _| { - do self.iter.string.as_imm_buf |b, len| { + let offset = self.string.as_imm_buf(|a, _| { + self.iter.string.as_imm_buf(|b, len| { b as uint - a as uint + len - } - }; + }) + }); (offset, ch) }) } @@ -716,14 +716,14 @@ impl<'self> Iterator<char> for NormalizationIterator<'self> { if !self.sorted { for ch in self.iter { - do decomposer(ch) |d| { + decomposer(ch, |d| { let class = canonical_combining_class(d); if class == 0 && !self.sorted { canonical_sort(self.buffer); self.sorted = true; } self.buffer.push((d, class)); - } + }); if self.sorted { break } } } @@ -781,8 +781,8 @@ Section: Comparing strings #[lang="str_eq"] #[inline] pub fn eq_slice(a: &str, b: &str) -> bool { - do a.as_imm_buf |ap, alen| { - do b.as_imm_buf |bp, blen| { + a.as_imm_buf(|ap, alen| { + b.as_imm_buf(|bp, blen| { if (alen != blen) { false } else { unsafe { @@ -791,16 +791,16 @@ pub fn eq_slice(a: &str, b: &str) -> bool { alen as libc::size_t) == 0 } } - } - } + }) + }) } /// Bytewise slice equality #[cfg(test)] #[inline] pub fn eq_slice(a: &str, b: &str) -> bool { - do a.as_imm_buf |ap, alen| { - do b.as_imm_buf |bp, blen| { + a.as_imm_buf(|ap, alen| { + b.as_imm_buf(|bp, blen| { if (alen != blen) { false } else { unsafe { @@ -809,8 +809,8 @@ pub fn eq_slice(a: &str, b: &str) -> bool { alen as libc::size_t) == 0 } } - } - } + }) + }) } /// Bytewise string equality @@ -1029,9 +1029,7 @@ pub mod raw { /// Create a Rust string from a *u8 buffer of the given length pub unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str { let mut v: ~[u8] = vec::with_capacity(len); - do v.as_mut_buf |vbuf, _len| { - ptr::copy_memory(vbuf, buf as *u8, len) - }; + v.as_mut_buf(|vbuf, _len| ptr::copy_memory(vbuf, buf as *u8, len)); vec::raw::set_len(&mut v, len); assert!(is_utf8(v)); @@ -1059,9 +1057,7 @@ pub mod raw { /// Converts a vector of bytes to a new owned string. pub unsafe fn from_utf8(v: &[u8]) -> ~str { - do v.as_imm_buf |buf, len| { - from_buf_len(buf, len) - } + v.as_imm_buf(|buf, len| from_buf_len(buf, len)) } /// Converts an owned vector of bytes to a new owned string. This assumes @@ -1112,12 +1108,12 @@ pub mod raw { /// Caller must check slice boundaries! #[inline] pub unsafe fn slice_unchecked<'a>(s: &'a str, begin: uint, end: uint) -> &'a str { - do s.as_imm_buf |sbuf, _n| { + s.as_imm_buf(|sbuf, _n| { cast::transmute(Slice { data: sbuf.offset(begin as int), len: end - begin, }) - } + }) } /// Appends a byte to a string. @@ -1351,7 +1347,7 @@ impl<'self> Str for @str { impl<'self> Container for &'self str { #[inline] fn len(&self) -> uint { - do self.as_imm_buf |_p, n| { n } + self.as_imm_buf(|_p, n| n) } } @@ -1876,11 +1872,11 @@ impl<'self> StrSlice<'self> for &'self str { } fn lines_any(&self) -> AnyLineIterator<'self> { - do self.lines().map |line| { + self.lines().map(|line| { let l = line.len(); if l > 0 && line[l - 1] == '\r' as u8 { line.slice(0, l - 1) } else { line } - } + }) } #[inline] @@ -1973,9 +1969,7 @@ impl<'self> StrSlice<'self> for &'self str { let mut out: ~str = ~""; out.reserve_at_least(self.len()); for c in self.chars() { - do c.escape_default |c| { - out.push_char(c); - } + c.escape_default(|c| out.push_char(c)); } out } @@ -1984,9 +1978,7 @@ impl<'self> StrSlice<'self> for &'self str { let mut out: ~str = ~""; out.reserve_at_least(self.len()); for c in self.chars() { - do c.escape_unicode |c| { - out.push_char(c); - } + c.escape_unicode(|c| out.push_char(c)); } out } @@ -2044,17 +2036,15 @@ impl<'self> StrSlice<'self> for &'self str { #[inline] fn to_owned(&self) -> ~str { - do self.as_imm_buf |src, len| { + self.as_imm_buf(|src, len| { unsafe { let mut v = vec::with_capacity(len); - do v.as_mut_buf |dst, _| { - ptr::copy_memory(dst, src, len); - } + v.as_mut_buf(|dst, _| ptr::copy_memory(dst, src, len)); vec::raw::set_len(&mut v, len); ::cast::transmute(v) } - } + }) } #[inline] @@ -2250,8 +2240,8 @@ impl<'self> StrSlice<'self> for &'self str { } fn subslice_offset(&self, inner: &str) -> uint { - do self.as_imm_buf |a, a_len| { - do inner.as_imm_buf |b, b_len| { + self.as_imm_buf(|a, a_len| { + inner.as_imm_buf(|b, b_len| { let a_start: uint; let a_end: uint; let b_start: uint; @@ -2263,8 +2253,8 @@ impl<'self> StrSlice<'self> for &'self str { assert!(a_start <= b_start); assert!(b_end <= a_end); b_start - a_start - } - } + }) + }) } #[inline] @@ -2382,11 +2372,11 @@ impl OwnedStr for ~str { // Attempt to not use an intermediate buffer by just pushing bytes // directly onto this string. - let used = do self.as_mut_buf |buf, _| { - do vec::raw::mut_buf_as_slice(buf.offset(cur_len as int), 4) |slc| { + let used = self.as_mut_buf(|buf, _| { + vec::raw::mut_buf_as_slice(buf.offset(cur_len as int), 4, |slc| { c.encode_utf8(slc) - } - }; + }) + }); raw::set_len(self, cur_len + used); } } @@ -3156,13 +3146,11 @@ mod tests { 0x6d_u8]; let mut error_happened = false; - let _x = do cond.trap(|err| { + let _x = cond.trap(|err| { assert_eq!(err, ~"from_utf8: input is not UTF-8; first bad byte is 255"); error_happened = true; ~"" - }).inside { - from_utf8(bb) - }; + }).inside(|| from_utf8(bb)); assert!(error_happened); } @@ -3201,11 +3189,9 @@ mod tests { #[test] fn test_as_imm_buf() { - do "".as_imm_buf |_, len| { - assert_eq!(len, 0); - } + "".as_imm_buf(|_, len| assert_eq!(len, 0)); - do "hello".as_imm_buf |buf, len| { + "hello".as_imm_buf(|buf, len| { assert_eq!(len, 5); unsafe { assert_eq!(*ptr::offset(buf, 0), 'h' as u8); @@ -3214,7 +3200,7 @@ mod tests { assert_eq!(*ptr::offset(buf, 3), 'l' as u8); assert_eq!(*ptr::offset(buf, 4), 'o' as u8); } - } + }) } #[test] @@ -3864,9 +3850,7 @@ mod bench { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; let len = s.char_len(); - do bh.iter { - assert_eq!(s.chars().len(), len); - } + bh.iter(|| assert_eq!(s.chars().len(), len)); } #[bench] @@ -3879,9 +3863,7 @@ mod bench { Mary had a little lamb, Little lamb"; let len = s.char_len(); - do bh.iter { - assert_eq!(s.chars().len(), len); - } + bh.iter(|| assert_eq!(s.chars().len(), len)); } #[bench] @@ -3889,9 +3871,7 @@ mod bench { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; let len = s.char_len(); - do bh.iter { - assert_eq!(s.chars_rev().len(), len); - } + bh.iter(|| assert_eq!(s.chars_rev().len(), len)); } #[bench] @@ -3899,9 +3879,7 @@ mod bench { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; let len = s.char_len(); - do bh.iter { - assert_eq!(s.char_indices().len(), len); - } + bh.iter(|| assert_eq!(s.char_indices().len(), len)); } #[bench] @@ -3909,18 +3887,14 @@ mod bench { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; let len = s.char_len(); - do bh.iter { - assert_eq!(s.char_indices_rev().len(), len); - } + bh.iter(|| assert_eq!(s.char_indices_rev().len(), len)); } #[bench] fn split_unicode_ascii(bh: &mut BenchHarness) { let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam"; - do bh.iter { - assert_eq!(s.split('V').len(), 3); - } + bh.iter(|| assert_eq!(s.split('V').len(), 3)); } #[bench] @@ -3934,9 +3908,7 @@ mod bench { } let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam"; - do bh.iter { - assert_eq!(s.split(NotAscii('V')).len(), 3); - } + bh.iter(|| assert_eq!(s.split(NotAscii('V')).len(), 3)); } @@ -3945,9 +3917,7 @@ mod bench { let s = "Mary had a little lamb, Little lamb, little-lamb."; let len = s.split(' ').len(); - do bh.iter { - assert_eq!(s.split(' ').len(), len); - } + bh.iter(|| assert_eq!(s.split(' ').len(), len)); } #[bench] @@ -3961,9 +3931,7 @@ mod bench { let s = "Mary had a little lamb, Little lamb, little-lamb."; let len = s.split(' ').len(); - do bh.iter { - assert_eq!(s.split(NotAscii(' ')).len(), len); - } + bh.iter(|| assert_eq!(s.split(NotAscii(' ')).len(), len)); } #[bench] @@ -3972,9 +3940,7 @@ mod bench { let len = s.split(' ').len(); fn pred(c: char) -> bool { c == ' ' } - do bh.iter { - assert_eq!(s.split(pred).len(), len); - } + bh.iter(|| assert_eq!(s.split(pred).len(), len)); } #[bench] @@ -3982,9 +3948,7 @@ mod bench { let s = "Mary had a little lamb, Little lamb, little-lamb."; let len = s.split(' ').len(); - do bh.iter { - assert_eq!(s.split(|c: char| c == ' ').len(), len); - } + bh.iter(|| assert_eq!(s.split(|c: char| c == ' ').len(), len)); } #[bench] @@ -3992,9 +3956,7 @@ mod bench { let s = "Mary had a little lamb, Little lamb, little-lamb."; let len = s.split(' ').len(); - do bh.iter { - assert_eq!(s.split(&[' ']).len(), len); - } + bh.iter(|| assert_eq!(s.split(&[' ']).len(), len)); } #[bench] @@ -4004,34 +3966,28 @@ mod bench { Lorem ipsum dolor sit amet, consectetur. "); assert_eq!(100, s.len()); - do bh.iter { - is_utf8(s); - } + bh.iter(|| is_utf8(s)); } #[bench] fn is_utf8_100_multibyte(bh: &mut BenchHarness) { let s = bytes!("𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰"); assert_eq!(100, s.len()); - do bh.iter { - is_utf8(s); - } + bh.iter(|| is_utf8(s)); } #[bench] fn bench_with_capacity(bh: &mut BenchHarness) { - do bh.iter { - with_capacity(100); - } + bh.iter(|| with_capacity(100)); } #[bench] fn bench_push_str(bh: &mut BenchHarness) { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; - do bh.iter { + bh.iter(|| { let mut r = ~""; r.push_str(s); - } + }); } #[bench] @@ -4039,8 +3995,8 @@ mod bench { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; let sep = "→"; let v = [s, s, s, s, s, s, s, s, s, s]; - do bh.iter { + bh.iter(|| { assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9); - } + }) } } diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index 485fe9edf0e..85f66d4ada8 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -432,12 +432,12 @@ pub fn with_task_name<U>(blk: |Option<&str>| -> U) -> U { use rt::task::Task; if in_green_task_context() { - do Local::borrow |task: &mut Task| { + Local::borrow(|task: &mut Task| { match task.name { Some(ref name) => blk(Some(name.as_slice())), None => blk(None) } - } + }) } else { fail!("no task name exists in non-green task context") } @@ -459,9 +459,7 @@ pub fn failing() -> bool { use rt::task::Task; - do Local::borrow |local: &mut Task| { - local.unwinder.unwinding - } + Local::borrow(|local: &mut Task| local.unwinder.unwinding) } // The following 8 tests test the following 2^3 combinations: diff --git a/src/libstd/to_bytes.rs b/src/libstd/to_bytes.rs index ded7cd8df07..d81fe0c2fbd 100644 --- a/src/libstd/to_bytes.rs +++ b/src/libstd/to_bytes.rs @@ -369,12 +369,12 @@ impl<A:IterBytes> ToBytes for A { use io::mem; use io::Writer; - do mem::with_mem_writer |wr| { - do self.iter_bytes(lsb0) |bytes| { + mem::with_mem_writer(|wr| { + self.iter_bytes(lsb0, |bytes| { wr.write(bytes); true - }; - } + }); + }) } } diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs index 9f5ee752089..8b534d7d3be 100644 --- a/src/libstd/trie.rs +++ b/src/libstd/trie.rs @@ -489,7 +489,7 @@ pub struct TrieSetIterator<'self> { impl<'self> Iterator<uint> for TrieSetIterator<'self> { fn next(&mut self) -> Option<uint> { - do self.iter.next().map |(key, _)| { key } + self.iter.next().map(|(key, _)| key) } fn size_hint(&self) -> (uint, Option<uint>) { @@ -594,12 +594,12 @@ mod test_map { assert!(m.insert(1, 2)); let mut n = 0; - do m.each |k, v| { + m.each(|k, v| { assert_eq!(*k, n); assert_eq!(*v, n * 2); n += 1; true - }; + }); } #[test] @@ -611,7 +611,7 @@ mod test_map { } let mut n = uint::max_value - 10000; - do m.each |k, v| { + m.each(|k, v| { if n == uint::max_value - 5000 { false } else { assert!(n < uint::max_value - 5000); @@ -620,7 +620,7 @@ mod test_map { n += 1; true } - }; + }); } #[test] @@ -634,12 +634,12 @@ mod test_map { assert!(m.insert(1, 2)); let mut n = 4; - do m.each_reverse |k, v| { + m.each_reverse(|k, v| { assert_eq!(*k, n); assert_eq!(*v, n * 2); n -= 1; true - }; + }); } #[test] @@ -651,7 +651,7 @@ mod test_map { } let mut n = uint::max_value - 1; - do m.each_reverse |k, v| { + m.each_reverse(|k, v| { if n == uint::max_value - 5000 { false } else { assert!(n > uint::max_value - 5000); @@ -660,7 +660,7 @@ mod test_map { n -= 1; true } - }; + }); } #[test] @@ -777,11 +777,11 @@ mod test_set { let mut i = 0; - do trie.each |x| { + trie.each(|x| { assert_eq!(expected[i], *x); i += 1; true - }; + }); } #[test] diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index a8f56228dcb..ac4bc5754fb 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -19,11 +19,11 @@ pub mod general_category { use cmp::{Equal, Less, Greater}; use vec::ImmutableVector; use option::None; - (do r.bsearch |&(lo,hi)| { + (r.bsearch(|&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } - }) != None + })) != None } @@ -3663,11 +3663,11 @@ pub mod derived_property { use cmp::{Equal, Less, Greater}; use vec::ImmutableVector; use option::None; - (do r.bsearch |&(lo,hi)| { + (r.bsearch(|&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } - }) != None + })) != None } diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs index cdfbf8c0049..2a6e40dc3a0 100644 --- a/src/libstd/unstable/dynamic_lib.rs +++ b/src/libstd/unstable/dynamic_lib.rs @@ -27,11 +27,11 @@ pub struct DynamicLibrary { priv handle: *libc::c_void } impl Drop for DynamicLibrary { fn drop(&mut self) { - match do dl::check_for_errors_in { + match dl::check_for_errors_in(|| { unsafe { dl::close(self.handle) } - } { + }) { Ok(()) => {}, Err(str) => fail!("{}", str) } @@ -43,12 +43,12 @@ impl DynamicLibrary { /// handle to the calling process pub fn open(filename: Option<&path::Path>) -> Result<DynamicLibrary, ~str> { unsafe { - let maybe_library = do dl::check_for_errors_in { + let maybe_library = dl::check_for_errors_in(|| { match filename { Some(name) => dl::open_external(name), None => dl::open_internal() } - }; + }); // The dynamic library must not be constructed if there is // an error opening the library so the destructor does not @@ -65,11 +65,11 @@ impl DynamicLibrary { // This function should have a lifetime constraint of 'self on // T but that feature is still unimplemented - let maybe_symbol_value = do dl::check_for_errors_in { - do symbol.with_c_str |raw_string| { + let maybe_symbol_value = dl::check_for_errors_in(|| { + symbol.with_c_str(|raw_string| { dl::symbol(self.handle, raw_string) - } - }; + }) + }); // The value must not be constructed if there is an error so // the destructor does not run. @@ -144,9 +144,9 @@ pub mod dl { use result::*; pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void { - do filename.with_c_str |raw_name| { + filename.with_c_str(|raw_name| { dlopen(raw_name, Lazy as libc::c_int) - } + }) } pub unsafe fn open_internal() -> *libc::c_void { @@ -162,7 +162,7 @@ pub mod dl { // would cause this task to be descheduled, which could deadlock // the scheduler if it happens while the lock is held. // FIXME #9105 use a Rust mutex instead of C++ mutexes. - do atomically { + atomically(|| { lock.lock(); let _old_error = dlerror(); @@ -176,7 +176,7 @@ pub mod dl { }; lock.unlock(); ret - } + }) } } @@ -213,9 +213,9 @@ pub mod dl { use result::*; pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void { - do os::win32::as_utf16_p(filename.as_str().unwrap()) |raw_name| { + os::win32::as_utf16_p(filename.as_str().unwrap(), |raw_name| { LoadLibraryW(raw_name) - } + }) } pub unsafe fn open_internal() -> *libc::c_void { @@ -226,7 +226,7 @@ pub mod dl { pub fn check_for_errors_in<T>(f: || -> T) -> Result<T, ~str> { unsafe { - do atomically { + atomically(|| { SetLastError(0); let result = f(); @@ -237,7 +237,7 @@ pub mod dl { } else { Err(format!("Error code {}", error)) } - } + }) } } diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs index 092e9b6d348..06f9ba65ae7 100644 --- a/src/libstd/unstable/lang.rs +++ b/src/libstd/unstable/lang.rs @@ -27,9 +27,7 @@ pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! { pub fn fail_bounds_check(file: *c_char, line: size_t, index: size_t, len: size_t) -> ! { let msg = format!("index out of bounds: the len is {} but the index is {}", len as uint, index as uint); - do msg.with_c_str |buf| { - fail_(buf, file, line); - } + msg.with_c_str(|buf| fail_(buf, file, line)) } #[lang="malloc"] diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index e80b58d01ef..1f243d08243 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -134,9 +134,8 @@ impl<T: Send> UnsafeArc<T> { /// If called when the task is already unkillable, unwrap will unkillably /// block; otherwise, an unwrapping task can be killed by linked failure. pub fn unwrap(self) -> T { - let this = Cell::new(self); // argh unsafe { - let mut this = this.take(); + let mut this = this; // The ~ dtor needs to run if this code succeeds. let mut data: ~ArcData<T> = cast::transmute(this.data); // Set up the unwrap protocol. @@ -164,7 +163,7 @@ impl<T: Send> UnsafeArc<T> { // Unlike the above one, this cell is necessary. It will get // taken either in the do block or in the finally block. let c2_and_data = Cell::new((c2,data)); - do (|| { + (|| { p1.take().recv(); // Got here. Back in the 'unkillable' without getting killed. let (c2, data) = c2_and_data.take(); @@ -174,7 +173,7 @@ impl<T: Send> UnsafeArc<T> { // user_data let mut data = data; data.data.take_unwrap() - }).finally { + }).finally(|| { if task::failing() { // Killed during wait. Because this might happen while // someone else still holds a reference, we can't free @@ -185,7 +184,7 @@ impl<T: Send> UnsafeArc<T> { } else { assert!(c2_and_data.is_empty()); } - } + }) } } else { // If 'put' returns the server end back to us, we were rejected; @@ -193,7 +192,7 @@ impl<T: Send> UnsafeArc<T> { cast::forget(data); fail!("Another task is already unwrapping this Arc!"); } - } + }) } /// As unwrap above, but without blocking. Returns 'UnsafeArcSelf(self)' if this is @@ -256,8 +255,6 @@ impl<T> Drop for UnsafeArc<T>{ // *awake* task with the data. match data.unwrapper.take(Acquire) { Some(~(message,response)) => { - let cell = Cell::new((message, response, data)); - let (message, response, data) = cell.take(); // Send 'ready' and wait for a response. message.send(()); // Unkillable wait. Message guaranteed to come. @@ -301,12 +298,10 @@ pub unsafe fn atomically<U>(f: || -> U) -> U { Some(t) => { match (*t).task_type { GreenTask(_) => { - do (|| { + (|| { (*t).death.inhibit_deschedule(); f() - }).finally { - (*t).death.allow_deschedule(); - } + }).finally(|| (*t).death.allow_deschedule()) } SchedTask => f() } @@ -425,9 +420,7 @@ impl<T:Send> Exclusive<T> { #[inline] pub unsafe fn with_imm<U>(&self, f: |x: &T| -> U) -> U { - do self.with |x| { - f(cast::transmute_immut(x)) - } + self.with(|x| f(cast::transmute_immut(x))) } #[inline] @@ -469,7 +462,6 @@ impl<T:Send> Exclusive<T> { #[cfg(test)] mod tests { - use cell::Cell; use comm; use option::*; use prelude::*; @@ -489,7 +481,7 @@ mod tests { fn test_atomically() { // NB. The whole runtime will abort on an 'atomic-sleep' violation, // so we can't really test for the converse behaviour. - unsafe { do atomically { } } task::deschedule(); // oughtn't fail + unsafe { atomically(|| ()) } task::deschedule(); // oughtn't fail } #[test] @@ -509,9 +501,7 @@ mod tests { do task::spawn || { for _ in range(0u, count) { - do total.with |count| { - **count += 1; - } + total.with(|count| **count += 1); } chan.send(()); } @@ -519,9 +509,7 @@ mod tests { for f in futures.iter() { f.recv() } - do total.with |total| { - assert!(**total == num_tasks * count) - }; + total.with(|total| assert!(**total == num_tasks * count)); } } @@ -533,13 +521,9 @@ mod tests { let x = Exclusive::new(1); let x2 = x.clone(); do task::try || { - do x2.with |one| { - assert_eq!(*one, 2); - } + x2.with(|one| assert_eq!(*one, 2)) }; - do x.with |one| { - assert_eq!(*one, 1); - } + x.with(|one| assert_eq!(*one, 1)); } } @@ -595,11 +579,11 @@ mod tests { fn arclike_try_unwrap_unwrap_race() { // When an unwrap and a try_unwrap race, the unwrapper should always win. let x = UnsafeArc::new(~~"hello"); - let x2 = Cell::new(x.clone()); + let x2 = x.clone(); let (p,c) = comm::stream(); do task::spawn { c.send(()); - assert!(x2.take().unwrap() == ~~"hello"); + assert!(x2.unwrap() == ~~"hello"); c.send(()); } p.recv(); @@ -620,21 +604,19 @@ mod tests { #[test] fn exclusive_new_unwrap_contended() { let x = Exclusive::new(~~"hello"); - let x2 = Cell::new(x.clone()); + let x2 = x.clone(); do task::spawn { - let x2 = x2.take(); - unsafe { do x2.with |_hello| { } } + unsafe { x2.with(|_hello| ()); } task::deschedule(); } assert!(x.unwrap() == ~~"hello"); // Now try the same thing, but with the child task blocking. let x = Exclusive::new(~~"hello"); - let x2 = Cell::new(x.clone()); + let x2 = x.clone(); let mut builder = task::task(); let res = builder.future_result(); do builder.spawn { - let x2 = x2.take(); assert!(x2.unwrap() == ~~"hello"); } // Have to get rid of our reference before blocking. @@ -645,11 +627,10 @@ mod tests { #[test] #[should_fail] fn exclusive_new_unwrap_conflict() { let x = Exclusive::new(~~"hello"); - let x2 = Cell::new(x.clone()); + let x2 = x.clone(); let mut builder = task::task(); let res = builder.future_result(); do builder.spawn { - let x2 = x2.take(); assert!(x2.unwrap() == ~~"hello"); } assert!(x.unwrap() == ~~"hello"); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 0b08f9d00fa..30627327d73 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -137,14 +137,14 @@ pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> ~[T] { let mut v = with_capacity(n_elts); let p = raw::to_mut_ptr(v); let mut i: uint = 0u; - do (|| { + (|| { while i < n_elts { intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i as int)), op(i)); i += 1u; } - }).finally { + }).finally(|| { raw::set_len(&mut v, i); - } + }); v } } @@ -164,14 +164,14 @@ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> ~[T] { let mut v = with_capacity(n_elts); let p = raw::to_mut_ptr(v); let mut i = 0u; - do (|| { + (|| { while i < n_elts { intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i as int)), t.clone()); i += 1u; } - }).finally { + }).finally(|| { raw::set_len(&mut v, i); - } + }); v } } @@ -982,14 +982,14 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { fn slice(&self, start: uint, end: uint) -> &'self [T] { assert!(start <= end); assert!(end <= self.len()); - do self.as_imm_buf |p, _len| { + self.as_imm_buf(|p, _len| { unsafe { cast::transmute(Slice { data: ptr::offset(p, start as int), len: (end - start) }) } - } + }) } #[inline] @@ -1639,7 +1639,7 @@ impl<T> OwnedVector<T> for ~[T] { self.pop() } fn truncate(&mut self, newlen: uint) { - do self.as_mut_buf |p, oldlen| { + self.as_mut_buf(|p, oldlen| { assert!(newlen <= oldlen); unsafe { // This loop is optimized out for non-drop types. @@ -1647,7 +1647,7 @@ impl<T> OwnedVector<T> for ~[T] { ptr::read_and_zero_ptr(ptr::mut_offset(p, i as int)); } } - } + }); unsafe { raw::set_len(self, newlen); } } @@ -1932,14 +1932,14 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] { fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] { assert!(start <= end); assert!(end <= self.len()); - do self.as_mut_buf |p, _len| { + self.as_mut_buf(|p, _len| { unsafe { cast::transmute(Slice { data: ptr::mut_offset(p, start as int) as *T, len: (end - start) }) } - } + }) } #[inline] @@ -2153,10 +2153,10 @@ pub mod raw { #[inline] pub unsafe fn init_elem<T>(v: &mut [T], i: uint, val: T) { let mut box = Some(val); - do v.as_mut_buf |p, _len| { + v.as_mut_buf(|p, _len| { intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i as int)), box.take_unwrap()); - } + }) } /** @@ -2188,11 +2188,11 @@ pub mod raw { assert!(dst.len() >= count); assert!(src.len() >= count); - do dst.as_mut_buf |p_dst, _len_dst| { - do src.as_imm_buf |p_src, _len_src| { + dst.as_mut_buf(|p_dst, _len_dst| { + src.as_imm_buf(|p_src, _len_src| { ptr::copy_memory(p_dst, p_src, count) - } - } + }) + }) } } @@ -2213,9 +2213,9 @@ pub mod bytes { impl<'self> MutableByteVector for &'self mut [u8] { #[inline] fn set_memory(self, value: u8) { - do self.as_mut_buf |p, len| { + self.as_mut_buf(|p, len| { unsafe { ptr::set_memory(p, value, len) }; - } + }) } } @@ -2278,11 +2278,11 @@ pub mod bytes { let old_len = dst.len(); dst.reserve_additional(src.len()); unsafe { - do dst.as_mut_buf |p_dst, len_dst| { - do src.as_imm_buf |p_src, len_src| { + dst.as_mut_buf(|p_dst, len_dst| { + src.as_imm_buf(|p_src, len_src| { ptr::copy_memory(p_dst.offset(len_dst as int), p_src, len_src) - } - } + }) + }); vec::raw::set_len(dst, old_len + src.len()); } } @@ -3276,10 +3276,10 @@ mod tests { #[test] #[should_fail] fn test_from_fn_fail() { - do from_fn(100) |v| { + from_fn(100, |v| { if v == 50 { fail!() } (~0, @0) - }; + }); } #[test] @@ -3308,25 +3308,25 @@ mod tests { #[test] #[should_fail] fn test_build_fail() { - do build(None) |push| { + build(None, |push| { push((~0, @0)); push((~0, @0)); push((~0, @0)); push((~0, @0)); fail!(); - }; + }); } #[test] #[should_fail] fn test_grow_fn_fail() { let mut v = ~[]; - do v.grow_fn(100) |i| { + v.grow_fn(100, |i| { if i == 50 { fail!() } (~0, @0) - } + }) } #[test] @@ -3334,13 +3334,13 @@ mod tests { fn test_map_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do v.map |_elt| { + v.map(|_elt| { if i == 2 { fail!() } i += 1; ~[(~0, @0)] - }; + }); } #[test] @@ -3348,13 +3348,13 @@ mod tests { fn test_flat_map_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do flat_map(v) |_elt| { + flat_map(v, |_elt| { if i == 2 { fail!() } i += 1; ~[(~0, @0)] - }; + }); } #[test] @@ -3374,18 +3374,18 @@ mod tests { #[should_fail] fn test_as_imm_buf_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; - do v.as_imm_buf |_buf, _i| { + v.as_imm_buf(|_buf, _i| { fail!() - } + }) } #[test] #[should_fail] fn test_as_mut_buf_fail() { let mut v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; - do v.as_mut_buf |_buf, _i| { + v.as_mut_buf(|_buf, _i| { fail!() - } + }) } #[test] @@ -3843,52 +3843,48 @@ mod bench { // out. let v = vec::from_fn(100, |i| i ^ (i << 1) ^ (i >> 1)); - do bh.iter { + bh.iter(|| { let mut sum = 0; for x in v.iter() { sum += *x; } // sum == 11806, to stop dead code elimination. if sum == 0 {fail!()} - } + }) } #[bench] fn mut_iterator(bh: &mut BenchHarness) { let mut v = vec::from_elem(100, 0); - do bh.iter { + bh.iter(|| { let mut i = 0; for x in v.mut_iter() { *x = i; i += 1; } - } + }) } #[bench] fn add(bh: &mut BenchHarness) { let xs: &[int] = [5, ..10]; let ys: &[int] = [5, ..10]; - do bh.iter() { + bh.iter(|| { xs + ys; - } + }); } #[bench] fn concat(bh: &mut BenchHarness) { let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect()); - do bh.iter { - xss.concat_vec(); - } + bh.iter(|| xss.concat_vec()); } #[bench] fn connect(bh: &mut BenchHarness) { let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect()); - do bh.iter { - xss.connect_vec(&0); - } + bh.iter(|| xss.connect_vec(&0)); } #[bench] |