parameters are used for, an example usage of this condition would be:
```rust
-do my_error::cond.trap(|raised_int| {
+my_error::cond.trap(|raised_int| {
// the condition `my_error` was raised on, and the value it raised is stored
// in `raised_int`. This closure must return a `~str` type (as specified in
// the declaration of the condition
if raised_int == 3 { ~"three" } else { ~"oh well" }
-}).inside {
+}).inside(|| {
// The condition handler above is installed for the duration of this block.
// That handler will override any previous handler, but the previous handler
println(my_error::cond.raise(3)); // prints "three"
println(my_error::cond.raise(4)); // prints "oh well"
-}
+})
```
Condition handling is useful in cases where propagating errors is either to
/// ```rust
/// condition! { my_error: int -> int; }
///
- /// let result = do my_error::cond.trap(|error| error + 3).inside {
+ /// let result = my_error::cond.trap(|error| error + 3).inside(|| {
/// my_error::cond.raise(4)
- /// };
+ /// });
/// assert_eq!(result, 7);
/// ```
pub fn inside<V>(&self, inner: 'self || -> V) -> V {
fn test_clone() {
let x = Gc::new(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(|x| *x), 20);
}
fn test_deep_clone() {
let x = Gc::new(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(|x| *x), 5);
}
#[cfg(windows)]
fn os_unlink(p: &CString) -> IoResult<()> {
super::mkerr_winbool(unsafe {
- as_utf16_p(p.as_str().unwrap(), |buf| libc::DeleteFileW(buf));
+ as_utf16_p(p.as_str().unwrap(), |buf| {
+ libc::DeleteFileW(buf)
+ })
})
}
blk.push(0);
- 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())
}
/// use num::Times;
/// let ten = 10 as uint;
/// let mut accum = 0;
-/// do ten.times { accum += 1; }
+/// ten.times(|| { accum += 1; })
/// ```
///
pub trait Times {
#[inline]
///
/// A convenience form for basic repetition. Given a uint `x`,
- /// `do x.times { ... }` executes the given block x times.
+ /// `x.times(|| { ... })` executes the given block x times.
///
/// Equivalent to `for uint::range(0, x) |_| { ... }`.
///
/// Not defined on all integer types to permit unambiguous
/// use with integer literals of inferred integer-type as
- /// the self-value (eg. `do 100.times { ... }`).
+ /// the self-value (eg. `100.times(|| { ... })`).
///
fn times(&self, it: ||) {
let mut i = *self;
#[bench]
fn alloc_obj_with_dtor(bh: &mut BenchHarness) {
- do bh.iter {
+ bh.iter(|| {
HasDtor { x : 10 };
- }
+ })
}
}
pbBuffer: *mut BYTE);
}
- do v.as_mut_buf |ptr, len| {
+ v.as_mut_buf(|ptr, len| {
unsafe {rust_win32_rand_gen(self.hcryptprov, len as DWORD, ptr)}
- }
+ })
}
}
fn with_lock<T>(f: || -> T) -> T {
static mut lock: Mutex = MUTEX_INIT;
- do (|| {
+ (|| {
unsafe {
lock.lock();
f()
}
- }).finally {
+ }).finally(|| {
unsafe {
lock.unlock();
}
- }
+ })
}
fn get_global_ptr() -> *mut Option<~~[~str]> {
// Copied from `os`.
unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~str] {
- do vec::from_fn(argc as uint) |i| {
+ vec::from_fn(argc as uint, |i| {
str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int))
- }
+ })
}
#[cfg(test)]
#[bench]
fn push(bh: &mut BenchHarness) {
let mut vec: ~[uint] = ~[0u];
- do bh.iter() {
+ bh.iter(|| {
vec.push(0);
- }
+ })
}
#[bench]
fn starts_with_same_vector(bh: &mut BenchHarness) {
let vec: ~[uint] = vec::from_fn(100, |i| i);
- do bh.iter() {
+ bh.iter(|| {
vec.starts_with(vec);
- }
+ })
}
#[bench]
fn starts_with_single_element(bh: &mut BenchHarness) {
let vec: ~[uint] = ~[0u];
- do bh.iter() {
+ bh.iter(|| {
vec.starts_with(vec);
- }
+ })
}
#[bench]
let vec: ~[uint] = vec::from_fn(100, |i| i);
let mut match_vec: ~[uint] = vec::from_fn(99, |i| i);
match_vec.push(0);
- do bh.iter() {
+ bh.iter(|| {
vec.starts_with(match_vec);
- }
+ })
}
#[bench]
fn ends_with_same_vector(bh: &mut BenchHarness) {
let vec: ~[uint] = vec::from_fn(100, |i| i);
- do bh.iter() {
+ bh.iter(|| {
vec.ends_with(vec);
- }
+ })
}
#[bench]
fn ends_with_single_element(bh: &mut BenchHarness) {
let vec: ~[uint] = ~[0u];
- do bh.iter() {
+ bh.iter(|| {
vec.ends_with(vec);
- }
+ })
}
#[bench]
let vec: ~[uint] = vec::from_fn(100, |i| i);
let mut match_vec: ~[uint] = vec::from_fn(100, |i| i);
match_vec[0] = 200;
- do bh.iter() {
+ bh.iter(|| {
vec.starts_with(match_vec);
- }
+ })
}
#[bench]
fn contains_last_element(bh: &mut BenchHarness) {
let vec: ~[uint] = vec::from_fn(100, |i| i);
- do bh.iter() {
+ bh.iter(|| {
vec.contains(&99u);
- }
+ })
}
}
projects / rust.git / commitdiff