spawn(print_message);
// Print something more profound in a different task using a lambda expression
-spawn( || println("I am also running in a different task!") );
+spawn(proc() println("I am also running in a different task!") );
// The canonical way to spawn is using `do` notation
do spawn {
12586269025
}
-let mut delayed_fib = extra::future::Future::spawn (|| fib(50) );
+let mut delayed_fib = extra::future::Future::spawn(proc() fib(50));
make_a_sandwich();
println!("fib(50) = {:?}", delayed_fib.get())
~~~
let config = Cell::new((*config).clone());
// FIXME (#9639): This needs to handle non-utf8 paths
let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
- test::DynTestFn(|| { runtest::run(config.take(), testfile.take()) })
+ test::DynTestFn(proc() { runtest::run(config.take(), testfile.take()) })
}
pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::TestFn {
let config = Cell::new((*config).clone());
// FIXME (#9639): This needs to handle non-utf8 paths
let testfile = Cell::new(testfile.as_str().unwrap().to_owned());
- test::DynMetricFn(|mm| { runtest::run_metrics(config.take(), testfile.take(), mm) })
+ test::DynMetricFn(proc(mm) {
+ runtest::run_metrics(config.take(), testfile.take(), mm)
+ })
}
#[test]
fn test_from_fn() {
- let mut f = Future::from_fn(|| ~"brail");
+ let mut f = Future::from_fn(proc() ~"brail");
assert_eq!(f.get(), ~"brail");
}
#[test]
fn test_spawn() {
- let mut f = Future::spawn(|| ~"bale");
+ let mut f = Future::spawn(proc() ~"bale");
assert_eq!(f.get(), ~"bale");
}
#[test]
#[should_fail]
fn test_futurefail() {
- let mut f = Future::spawn(|| fail!());
+ let mut f = Future::spawn(proc() fail!());
let _x: ~str = f.get();
}
let (port, chan) = comm::stream::<Msg<T>>();
let init_fn = init_fn_factory();
- let task_body: proc() = || {
+ let task_body: proc() = proc() {
let local_data = init_fn(i);
loop {
match port.recv() {
#[test]
fn test_task_pool() {
let f: || -> proc(uint) -> uint = || {
- let g: proc(uint) -> uint = |i| i;
+ let g: proc(uint) -> uint = proc(i) i;
g
};
let mut pool = TaskPool::new(4, Some(SingleThreaded), f);
8.times(|| {
- pool.execute(|i| println!("Hello from thread {}!", *i));
+ pool.execute(proc(i) println!("Hello from thread {}!", *i));
})
}
return;
}
DynTestFn(f) => run_test_inner(desc, monitor_ch, f),
- StaticTestFn(f) => run_test_inner(desc, monitor_ch, || f())
+ StaticTestFn(f) => run_test_inner(desc, monitor_ch, proc() f())
}
}
ignore: true,
should_fail: false
},
- testfn: DynTestFn(|| f()),
+ testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
ignore: true,
should_fail: false
},
- testfn: DynTestFn(|| f()),
+ testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
ignore: false,
should_fail: true
},
- testfn: DynTestFn(|| f()),
+ testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
ignore: false,
should_fail: true
},
- testfn: DynTestFn(|| f()),
+ testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
ignore: true,
should_fail: false,
},
- testfn: DynTestFn(|| {}),
+ testfn: DynTestFn(proc() {}),
},
TestDescAndFn {
desc: TestDesc {
ignore: false,
should_fail: false
},
- testfn: DynTestFn(|| {}),
+ testfn: DynTestFn(proc() {}),
},
];
let filtered = filter_tests(&opts, tests);
task_builder.opts.stack_size = Some(STACK_SIZE);
}
- match task_builder.try(|| {
+ match task_builder.try(proc() {
let ch = ch_capture.clone();
// The 'diagnostics emitter'. Every error, warning, etc. should
// go through this function.
pub fn main_args(args: &[~str]) -> int {
let owned_args = args.to_owned();
- monitor(|demitter| run_compiler(owned_args, demitter));
+ monitor(proc(demitter) run_compiler(owned_args, demitter));
0
}
_match::check_match(fcx, expr, discrim, *arms);
}
ast::ExprFnBlock(ref decl, ref body) => {
- check_expr_fn(fcx, expr, None,
- decl, body, Vanilla, expected);
+ check_expr_fn(fcx,
+ expr,
+ Some(ast::BorrowedSigil),
+ decl,
+ body,
+ Vanilla,
+ expected);
}
ast::ExprProc(ref decl, ref body) => {
check_expr_fn(fcx,
let psp = package_script_path.clone();
let ws = workspace.clone();
let pid = pkgid.clone();
- prep.exec(|exec| {
+ prep.exec(proc(exec) {
let mut pscript = PkgScript::parse(subsysroot.clone(),
psp.clone(),
&ws,
let sub_target_ex = target_exec.clone();
let sub_target_lib = target_lib.clone();
let sub_build_inputs = build_inputs.to_owned();
- prep.exec(|exe_thing| {
+ prep.exec(proc(exe_thing) {
let mut outputs = ~[];
// Declare all the *inputs* to the declared input too, as inputs
for executable in subex.iter() {
let sub_deps = deps.clone();
let inputs = inputs_to_discover.map(|&(ref k, ref p)|
(k.clone(), p.as_str().unwrap().to_owned()));
- prep.exec(|exec| {
+ prep.exec(proc(exec) {
for &(ref kind, ref p) in inputs.iter() {
let pth = Path::new(p.clone());
exec.discover_input(*kind, *p, if *kind == ~"file" {
let handle2 = Cell::new(sched2.make_handle());
let tasksFriendHandle = Cell::new(sched2.make_handle());
- let on_exit: proc(UnwindResult) = |exit_status| {
+ let on_exit: proc(UnwindResult) = proc(exit_status) {
handle1.take().send(Shutdown);
handle2.take().send(Shutdown);
assert!(exit_status.is_success());
})
}
- let test_function: proc() = || {
+ let test_function: proc() = proc() {
let io = unsafe { local_io() };
let addr = next_test_ip4();
let maybe_socket = io.udp_bind(addr);
#[test]
fn smoke() {
- smalltest(|mut server| {
+ smalltest(proc(mut server) {
let mut buf = [0];
server.read(buf);
assert!(buf[0] == 99);
- }, |mut client| {
+ }, proc(mut client) {
client.write([99]);
})
}
#[test]
fn read_eof() {
- smalltest(|mut server| {
+ smalltest(proc(mut server) {
let mut buf = [0];
assert!(server.read(buf).is_none());
assert!(server.read(buf).is_none());
- }, |_client| {
+ }, proc(_client) {
// drop the client
})
}
#[test]
fn write_begone() {
- smalltest(|mut server| {
+ smalltest(proc(mut server) {
let buf = [0];
let mut stop = false;
while !stop{
server.write(buf);
})
}
- }, |_client| {
+ }, proc(_client) {
// drop the client
})
}
do run_in_bare_thread {
local_ptr::init_tls_key();
let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+ let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
do run_in_bare_thread {
local_ptr::init_tls_key();
let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+ let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
- let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+ let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
do run_in_bare_thread {
local_ptr::init_tls_key();
let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+ let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
Local::put(task);
unsafe {
do run_in_bare_thread {
local_ptr::init_tls_key();
let mut sched = ~new_test_uv_sched();
- let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
+ let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
Local::put(task);
let res = Local::borrow(|_task: &mut Task| {
// When the main task exits, after all the tasks in the main
// task tree, shut down the schedulers and set the exit code.
- let handles = Cell::new(handles);
- let on_exit: proc(UnwindResult) = |exit_success| {
+ let handles = handles;
+ let on_exit: proc(UnwindResult) = proc(exit_success) {
unsafe {
assert!(!(*exited_already.get()).swap(true, SeqCst),
"the runtime already exited");
}
- let mut handles = handles.take();
+ let mut handles = handles;
for handle in handles.mut_iter() {
handle.send(Shutdown);
}
assert!(Task::on_appropriate_sched());
};
- let on_exit: proc(UnwindResult) = |exit_status| {
+ let on_exit: proc(UnwindResult) = proc(exit_status) {
rtassert!(exit_status.is_success())
};
task.death.on_exit = Some(on_exit);
let thread = do Thread::start {
let mut sched = sched.take();
- let bootstrap_task = ~Task::new_root(&mut sched.stack_pool, None, ||());
+ let bootstrap_task =
+ ~Task::new_root(&mut sched.stack_pool,
+ None,
+ proc()());
sched.bootstrap(bootstrap_task);
};
let mut stack_pool = StackPool::new();
- let task = ~Task::new_root(&mut stack_pool, None, ||());
+ let task = ~Task::new_root(&mut stack_pool, None, proc()());
handle.send(TaskFromFriend(task));
handle.send(Shutdown);
fn build_start_wrapper(start: proc()) -> proc() {
let start_cell = Cell::new(start);
- let wrapper: proc() = || {
+ let wrapper: proc() = proc() {
// First code after swap to this new context. Run our
// cleanup job.
unsafe {
#[test]
fn unwind() {
do run_in_newsched_task() {
- let result = spawntask_try(||());
+ let result = spawntask_try(proc()());
rtdebug!("trying first assert");
assert!(result.is_ok());
- let result = spawntask_try(|| fail!());
+ let result = spawntask_try(proc() fail!());
rtdebug!("trying second assert");
assert!(result.is_err());
}
use rt::sched::Shutdown;
let mut sched = ~new_test_uv_sched();
- let exit_handle = Cell::new(sched.make_handle());
+ let exit_handle = sched.make_handle();
- let on_exit: proc(UnwindResult) = |exit_status| {
- exit_handle.take().send(Shutdown);
+ let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
+ let mut exit_handle = exit_handle;
+ exit_handle.send(Shutdown);
rtassert!(exit_status.is_success());
};
let mut task = ~Task::new_root(&mut sched.stack_pool, None, f);
use rt::sched::Shutdown;
let mut sched = ~new_test_sched();
- let exit_handle = Cell::new(sched.make_handle());
+ let exit_handle = sched.make_handle();
- let on_exit: proc(UnwindResult) = |exit_status| {
- exit_handle.take().send(Shutdown);
+ let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
+ let mut exit_handle = exit_handle;
+ exit_handle.send(Shutdown);
rtassert!(exit_status.is_success());
};
let mut task = ~Task::new_root(&mut sched.stack_pool, None, f);
scheds.push(sched);
}
- let handles = Cell::new(handles);
- let on_exit: proc(UnwindResult) = |exit_status| {
- let mut handles = handles.take();
+ let handles = handles; // Work around not being able to capture mut
+ let on_exit: proc(UnwindResult) = proc(exit_status: UnwindResult) {
// Tell schedulers to exit
+ let mut handles = handles;
for handle in handles.mut_iter() {
handle.send(Shutdown);
}
pub fn spawntask_try(f: proc()) -> Result<(),()> {
let (port, chan) = oneshot();
- let chan = Cell::new(chan);
- let on_exit: proc(UnwindResult) = |exit_status| chan.take().send(exit_status);
+ let on_exit: proc(UnwindResult) = proc(exit_status) {
+ chan.send(exit_status)
+ };
let mut new_task = Task::build_root(None, f);
new_task.death.on_exit = Some(on_exit);
pub fn with_test_task(blk: proc(~Task) -> ~Task) {
do run_in_bare_thread {
let mut sched = ~new_test_sched();
- let task = blk(~Task::new_root(&mut sched.stack_pool, None, ||{}));
+ let task = blk(~Task::new_root(&mut sched.stack_pool,
+ None,
+ proc() {}));
cleanup_task(task);
}
}
let prev_gen_body = match prev_gen_body {
Some(gen) => gen,
None => {
- let f: proc(proc()) -> proc() = |body| body;
+ let f: proc(proc()) -> proc() = proc(body) body;
f
}
};
let prev_gen_body = Cell::new(prev_gen_body);
let next_gen_body = {
- let f: proc(proc()) -> proc() = |body| {
+ let f: proc(proc()) -> proc() = proc(body) {
let prev_gen_body = prev_gen_body.take();
wrapper(prev_gen_body(body))
};
let ch = Cell::new(ch);
do b0.add_wrapper |body| {
let ch = Cell::new(ch.take());
- let result: proc() = || {
+ let result: proc() = proc() {
let ch = ch.take();
body();
ch.send(());
// valgrind-friendly. try this at home, instead..!)
static generations: uint = 16;
fn child_no(x: uint) -> proc() {
- return || {
+ return proc() {
if x < generations {
let mut t = task();
t.unwatched();
use rt::test::run_in_uv_task;
do run_in_uv_task {
- spawn(||())
+ spawn(proc()())
}
}
if opts.notify_chan.is_some() {
let notify_chan = opts.notify_chan.take_unwrap();
let notify_chan = Cell::new(notify_chan);
- let on_exit: proc(UnwindResult) = |task_result| {
+ let on_exit: proc(UnwindResult) = proc(task_result) {
notify_chan.take().send(task_result)
};
task.death.on_exit = Some(on_exit);
let (p, ch) = stream();
let ch = SharedChan::new(ch);
- let _t = task::spawn(|| pfib(&ch, n) );
+ let _t = task::spawn(proc() pfib(&ch, n) );
p.recv()
}
};
let n = from_str::<uint>(args[1]).unwrap();
let mut i = 0u;
- while i < n { task::spawn(|| f(n) ); i += 1u; }
+ while i < n { task::spawn(proc() f(n) ); i += 1u; }
}
let v = ~3;
let _w = &v;
- task::spawn(|| {
+ task::spawn(proc() {
info!("v={}", *v);
//~^ ERROR cannot move
});
// you get two error reports here.
let bar = ~3;
let _g = || { //~ ERROR capture of moved value
- let _h: proc() -> int = || *bar; //~ ERROR capture of moved value
+ let _h: proc() -> int = proc() *bar; //~ ERROR capture of moved value
};
}
fn main() {
let t = ~3;
- call_f(|| { *t + 1 });
- call_f(|| { *t + 1 }); //~ ERROR capture of moved value
+ call_f(proc() { *t + 1 });
+ call_f(proc() { *t + 1 }); //~ ERROR capture of moved value
}
fn main() {
let x = @3u;
- let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
- let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
- let _: proc() = || foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc() = proc() foo(x); //~ ERROR does not fulfill `Send`
}
fn main() {
let y = ~0;
- let x: @proc() = @(|| {
+ let x: @proc() = @(proc() {
error!("{:?}", y.clone());
});
failfn();
}
pub fn main() {
- let x = asSendfn(|| 22u);
+ let x = asSendfn(proc() 22u);
assert_eq!(x, 22u);
let x = asBlock(|| 22u);
assert_eq!(x, 22u);
pub fn main() {
let bar = ~3;
- let h: proc() -> int = || *bar;
+ let h: proc() -> int = proc() *bar;
assert_eq!(h(), 3);
}
pub fn main() {
let x = ~3;
let y = ptr::to_unsafe_ptr(&(*x)) as uint;
- let snd_move: proc() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint;
+ let snd_move: proc() -> uint = proc() ptr::to_unsafe_ptr(&(*x)) as uint;
assert_eq!(snd_move(), y);
let x = ~4;
let y = ptr::to_unsafe_ptr(&(*x)) as uint;
- let lam_move: proc() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint;
+ let lam_move: proc() -> uint = proc() ptr::to_unsafe_ptr(&(*x)) as uint;
assert_eq!(lam_move(), y);
}
fn child2(_s: ~str) { }
pub fn main() {
- let _x = task::spawn(|| child2(~"hi"));
+ let _x = task::spawn(proc() child2(~"hi"));
}
fn adder(x: @int, y: @int) -> int { return *x + *y; }
fn failer() -> @int { fail!(); }
pub fn main() {
- assert!(task::try(|| {
+ assert!(task::try(proc() {
adder(@2, failer()); ()
}).is_err());
}
pub fn main() {
let z = ~Pair { a : 10, b : 12};
- let f: proc() = || {
+ let f: proc() = proc() {
assert_eq!(z.a, 10);
assert_eq!(z.b, 12);
};
pub fn main() {
let (p, ch) = stream();
- let _t = task::spawn(|| child(&ch) );
+ let _t = task::spawn(proc() child(&ch));
let y = p.recv();
error!("received");
error!("{:?}", y);
for i in inputs.iter() {
let ctrl = ctrl.clone();
let i = i.clone();
- task::spawn(|| map_task(ctrl.clone(), i.clone()) );
+ task::spawn(proc() map_task(ctrl.clone(), i.clone()) );
}
}
fn tester()
{
- let loader: rsrc_loader = |_path| {result::Ok(~"more blah")};
+ let loader: rsrc_loader = proc(_path) {result::Ok(~"more blah")};
let path = path::Path::new("blah");
assert!(loader(&path).is_ok());
fn foo(name: ~str, samples_chan: Chan<Msg>) {
do task::spawn
{
- let callback: SamplesFn =
- |buffer|
- {
- for i in range(0u, buffer.len()) {
- error!("{}: {}", i, buffer[i])
- }
- };
+ let callback: SamplesFn = proc(buffer) {
+ for i in range(0u, buffer.len()) {
+ error!("{}: {}", i, buffer[i])
+ }
+ };
samples_chan.send(GetSamples(name.clone(), callback));
};
}
pub fn main() {
let (p, ch) = stream::<~[u8]>();
- let _prod = task::spawn(|| producer(&ch) );
+ let _prod = task::spawn(proc() producer(&ch) );
let _data: ~[u8] = p.recv();
}
// Test that the lambda kind is inferred correctly as a return
// expression
-fn unique() -> proc() { return || (); }
+fn unique() -> proc() { return proc() (); }
pub fn main() {
}
// Test that the lambda kind is inferred correctly as a return
// expression
-fn unique() -> proc() { || () }
+fn unique() -> proc() { proc() () }
pub fn main() {
}
assert_eq!(q.y, !(p.y));
// Issue #1733
- let result: proc(int) = |_|();
+ let result: proc(int) = proc(_)();
result(p[true]);
}
fn test05() {
let three = ~3;
- let fn_to_send: proc(int) = |n| {
+ let fn_to_send: proc(int) = proc(n) {
error!("{}", *three + n); // will copy x into the closure
assert_eq!(*three, 3);
};
let fn_to_send = Cell::new(fn_to_send);
- task::spawn(|| {
+ task::spawn(proc() {
test05_start(fn_to_send.take());
});
}
}
pub fn main() {
- task::spawn(|| x(~"hello from first spawned fn", 65) );
- task::spawn(|| x(~"hello from second spawned fn", 66) );
- task::spawn(|| x(~"hello from third spawned fn", 67) );
+ task::spawn(proc() x(~"hello from first spawned fn", 65) );
+ task::spawn(proc() x(~"hello from second spawned fn", 66) );
+ task::spawn(proc() x(~"hello from third spawned fn", 67) );
let mut i: int = 30;
while i > 0 { i = i - 1; info!("parent sleeping"); task::deschedule(); }
}
pub fn main() {
let (_p, ch) = stream::<int>();
- task::spawn(|| iotask(&ch, ~"localhost") );
+ task::spawn(proc() iotask(&ch, ~"localhost") );
}
use std::task;
pub fn main() {
- task::spawn(|| child(10) );
+ task::spawn(proc() child(10) );
}
fn child(i: int) { error!("{}", i); assert!((i == 10)); }
use std::task;
-pub fn main() { task::spawn(|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
+pub fn main() { task::spawn(proc() child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
fn child(args: (int, int, int, int, int, int, int, int, int)) {
let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
fn main() {
let mut t = task::task();
t.sched_mode(task::SingleThreaded);
- t.spawn(|| ());
+ t.spawn(proc() ());
}
name: DynTestName(~"test"),
should_fail: false
},
- testfn: DynTestFn(|| ()),
+ testfn: DynTestFn(proc() ()),
};
do_swap(&mut test);
}
fn test05() {
let (po, ch) = comm::stream();
- task::spawn(|| test05_start(&ch) );
+ task::spawn(proc() test05_start(&ch) );
let mut value: int = po.recv();
error!("{}", value);
value = po.recv();
fn start() { info!("Started / Finished task."); }
fn test00() {
- task::try(|| start() );
+ task::try(proc() start() );
info!("Completing.");
}
pub fn main() {
let (p, ch) = comm::stream();
- let _child = task::spawn(|| start(&ch) );
+ let _child = task::spawn(proc() start(&ch) );
let c = p.recv();
c.send(~"A");
pub fn main() {
let (p, ch) = comm::stream();
- let _child = task::spawn(|| start(&ch) );
+ let _child = task::spawn(proc() start(&ch) );
let _c = p.recv();
}
pub fn main() {
info!("Check that we don't deadlock.");
let (_p, ch) = comm::stream();
- task::try(|| start(&ch, 0, 10) );
+ task::try(proc() start(&ch, 0, 10) );
info!("Joined task");
}
while (i > 0) {
info!("{}", i);
let ch = ch.clone();
- task::spawn({let i = i; || child(i, &ch)});
+ task::spawn({let i = i; proc() child(i, &ch)});
i = i - 1;
}
// the child's point of view the receiver may die. We should
// drop messages on the floor in this case, and not crash!
let (p, ch) = comm::stream();
- task::spawn(|| start(&ch, 10));
+ task::spawn(proc() start(&ch, 10));
p.recv();
}
}
pub fn main() {
- task::spawn(|| f() );
+ task::spawn(proc() f() );
}
results.push(builder.future_result());
builder.spawn({
let i = i;
- || test00_start(&ch, i, number_of_messages)
+ proc() test00_start(&ch, i, number_of_messages)
});
i = i + 1;
}
use std::task;
pub fn main() {
- task::spawn(|| child(~"Hello") );
+ task::spawn(proc() child(~"Hello") );
}
fn child(_s: ~str) {
let x = ~1;
let x_in_parent = ptr::to_unsafe_ptr(&(*x)) as uint;
- task::spawn(|| {
+ task::spawn(proc() {
let x_in_child = ptr::to_unsafe_ptr(&(*x)) as uint;
ch.send(x_in_child);
});
fn test_rm_tempdir() {
let (rd, wr) = stream();
- let f: proc() = || {
+ let f: proc() = proc() {
let tmp = TempDir::new("test_rm_tempdir").unwrap();
wr.send(tmp.path().clone());
fail!("fail to unwind past `tmp`");
let tmp = TempDir::new("test_rm_tempdir").unwrap();
let path = tmp.path().clone();
let cell = Cell::new(tmp);
- let f: proc() = || {
+ let f: proc() = proc() {
let _tmp = cell.take();
fail!("fail to unwind past `tmp`");
};
let path;
{
- let f: proc() -> TempDir = || {
+ let f: proc() -> TempDir = proc() {
TempDir::new("test_rm_tempdir").unwrap()
};
let tmp = task::try(f).expect("test_rm_tmdir");
fn test_fail() {
fn f() { let _x: @int = fail!(); }
- task::try(|| f() );
+ task::try(proc() f() );
}
fn test_fail_indirect() {
fn f() -> ! { fail!(); }
fn g() { let _x: @int = f(); }
- task::try(|| g() );
+ task::try(proc() g() );
}
pub fn main() {
pub fn main() {
let mut i = 10;
- while i > 0 { task::spawn({let i = i; || child(i)}); i = i - 1; }
+ while i > 0 { task::spawn({let i = i; proc() child(i)}); i = i - 1; }
info!("main thread exiting");
}
}
fn make_uniq_closure<A:Send>(a: A) -> proc() -> uint {
- let result: proc() -> uint = || ptr::to_unsafe_ptr(&a) as uint;
+ let result: proc() -> uint = proc() ptr::to_unsafe_ptr(&a) as uint;
result
}
return @mut Pointy {
a : none,
c : ~22,
- d : || {},
+ d : proc() {},
}
}
let mut expected = 0u;
for i in range(0u, n) {
let ch = ch.clone();
- task::spawn(|| child(&ch, i) );
+ task::spawn(proc() child(&ch, i) );
expected += i;
}
pub fn main() {
let (p, c) = stream();
let c = SharedChan::new(c);
- task::spawn(|| f(c.clone()) );
+ task::spawn(proc() f(c.clone()));
error!("hiiiiiiiii");
assert!(p.recv());
}
projects / rust.git / commitdiff