nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-10-31 06:22:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

librustc: Make || lambdas not infer to procs

Browse Source
This commit is contained in:
Patrick Walton 2013-11-21 23:36:52 -08:00
parent 38efa17bb8
commit 749ee53c6d
64 changed files with 139 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/tutorial-tasks.md
View File

@ -76,7 +76,7 @@ fn print_message() { println("I am running in a different task!"); }
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 {
@ -278,7 +278,7 @@ fn fib(n: u64) -> u64 {
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())
~~~

6
src/compiletest/compiletest.rs
View File

@ -333,7 +333,7 @@ pub fn make_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::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 {
@ -341,5 +341,7 @@ pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::Test
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)
})
}

6
src/libextra/future.rs
View File

@ -161,7 +161,7 @@ mod test {
#[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");
}
@ -185,14 +185,14 @@ mod test {
#[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();
}

6
src/libextra/task_pool.rs
View File

@ -57,7 +57,7 @@ impl<T> TaskPool<T> {
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() {
@ -98,11 +98,11 @@ impl<T> TaskPool<T> {
#[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));
})
}

14
src/libextra/test.rs
View File

@ -912,7 +912,7 @@ pub fn run_test(force_ignore: bool,
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())
}
}
@ -1209,7 +1209,7 @@ mod tests {
ignore: true,
should_fail: false
},
testfn: DynTestFn(|| f()),
testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
@ -1227,7 +1227,7 @@ mod tests {
ignore: true,
should_fail: false
},
testfn: DynTestFn(|| f()),
testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
@ -1245,7 +1245,7 @@ mod tests {
ignore: false,
should_fail: true
},
testfn: DynTestFn(|| f()),
testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
@ -1263,7 +1263,7 @@ mod tests {
ignore: false,
should_fail: true
},
testfn: DynTestFn(|| f()),
testfn: DynTestFn(proc() f()),
};
let (p, ch) = stream();
let ch = SharedChan::new(ch);
@ -1318,7 +1318,7 @@ mod tests {
ignore: true,
should_fail: false,
},
testfn: DynTestFn(|| {}),
testfn: DynTestFn(proc() {}),
},
TestDescAndFn {
desc: TestDesc {
@ -1326,7 +1326,7 @@ mod tests {
ignore: false,
should_fail: false
},
testfn: DynTestFn(|| {}),
testfn: DynTestFn(proc() {}),
},
];
let filtered = filter_tests(&opts, tests);

4
src/librustc/lib.rs
View File

@ -345,7 +345,7 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
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.
@ -403,6 +403,6 @@ pub fn main() {
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
}

9
src/librustc/middle/typeck/check/mod.rs
View File

@ -2905,8 +2905,13 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
_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,

4
src/librustpkg/lib.rs
View File

@ -474,7 +474,7 @@ impl CtxMethods for BuildContext {
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,
@ -636,7 +636,7 @@ impl CtxMethods for BuildContext {
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() {

2
src/librustpkg/package_source.rs
View File

@ -412,7 +412,7 @@ impl PkgSrc {
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" {

4
src/librustuv/net.rs
View File

@ -1092,7 +1092,7 @@ mod test {
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());
@ -1106,7 +1106,7 @@ mod test {
})
}
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);

12
src/libstd/io/net/unix.rs
View File

@ -214,29 +214,29 @@ mod tests {
#[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{
@ -248,7 +248,7 @@ mod tests {
server.write(buf);
})
}
}, |_client| {
}, proc(_client) {
// drop the client
})
}

10
src/libstd/rt/local.rs
View File

@ -134,7 +134,7 @@ mod test {
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);
@ -146,11 +146,11 @@ mod test {
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);
@ -163,7 +163,7 @@ mod test {
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 {
@ -179,7 +179,7 @@ mod test {
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| {

6
src/libstd/rt/mod.rs
View File

@ -340,14 +340,14 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
// 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);
}

9
src/libstd/rt/sched.rs
View File

@ -979,7 +979,7 @@ mod test {
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);
@ -1193,12 +1193,15 @@ mod test {
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);

6
src/libstd/rt/task.rs
View File

@ -425,7 +425,7 @@ impl Coroutine {
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 {
@ -712,10 +712,10 @@ mod test {
#[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());
}

29
src/libstd/rt/test.rs
View File

@ -83,10 +83,11 @@ pub fn run_in_uv_task_core(f: proc()) {
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);
@ -99,10 +100,11 @@ pub fn run_in_newsched_task_core(f: proc()) {
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);
@ -244,10 +246,10 @@ pub fn run_in_mt_newsched_task(f: proc()) {
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);
}
@ -319,8 +321,9 @@ pub fn spawntask_random(f: proc()) {
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);
@ -348,7 +351,9 @@ pub fn spawntask_thread(f: proc()) -> Thread {
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);
}
}

10
src/libstd/task/mod.rs
View File

@ -280,13 +280,13 @@ impl TaskBuilder {
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))
};
@ -551,7 +551,7 @@ fn test_add_wrapper() {
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(());
@ -765,7 +765,7 @@ fn test_child_doesnt_ref_parent() {
// 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();
@ -783,7 +783,7 @@ fn test_simple_newsched_spawn() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
spawn(||())
spawn(proc()())
}
}

2
src/libstd/task/spawn.rs
View File

@ -180,7 +180,7 @@ pub fn spawn_raw(mut opts: TaskOpts, f: 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);

2
src/test/bench/shootout-pfib.rs
View File

@ -46,7 +46,7 @@ fn fib(n: int) -> int {
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()
}

2
src/test/bench/task-perf-spawnalot.rs
View File

@ -33,5 +33,5 @@ fn main() {
};
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; }
}

2
src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
View File

@ -24,7 +24,7 @@ fn box_imm() {
let v = ~3;
let _w = &v;
task::spawn(|| {
task::spawn(proc() {
info!("v={}", *v);
//~^ ERROR cannot move
});

2
src/test/compile-fail/borrowck-move-by-capture.rs
View File

@ -3,6 +3,6 @@ pub fn main() {
// 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
};
}

4
src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
View File

@ -5,6 +5,6 @@ fn call_f(f: proc() -> int) -> int {
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
}

6
src/test/compile-fail/kindck-nonsendable-1.rs
View File

@ -14,7 +14,7 @@ fn foo(_x: @uint) {}
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`
}

2
src/test/run-fail/unwind-box-fn-unique.rs
View File

@ -18,7 +18,7 @@ fn failfn() {
fn main() {
let y = ~0;
let x: @proc() = @(|| {
let x: @proc() = @(proc() {
error!("{:?}", y.clone());
});
failfn();

2
src/test/run-pass/block-arg-call-as.rs
View File

@ -19,7 +19,7 @@ fn asBlock(f: || -> uint) -> uint {
}
pub fn main() {
let x = asSendfn(|| 22u);
let x = asSendfn(proc() 22u);
assert_eq!(x, 22u);
let x = asBlock(|| 22u);
assert_eq!(x, 22u);

2
src/test/run-pass/borrowck-move-by-capture-ok.rs
View File

@ -1,5 +1,5 @@
pub fn main() {
let bar = ~3;
let h: proc() -> int = || *bar;
let h: proc() -> int = proc() *bar;
assert_eq!(h(), 3);
}

4
src/test/run-pass/cap-clause-move.rs
View File

@ -13,11 +13,11 @@ use std::ptr;
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);
}

2
src/test/run-pass/child-outlives-parent.rs
View File

@ -15,5 +15,5 @@ use std::task;
fn child2(_s: ~str) { }
pub fn main() {
let _x = task::spawn(|| child2(~"hi"));
let _x = task::spawn(proc() child2(~"hi"));
}

2
src/test/run-pass/cleanup-copy-mode.rs
View File

@ -15,7 +15,7 @@ use std::task;
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());
}

2
src/test/run-pass/clone-with-exterior.rs
View File

@ -19,7 +19,7 @@ struct Pair {
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);
};

2
src/test/run-pass/comm.rs
View File

@ -12,7 +12,7 @@ use std::task;
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);

2
src/test/run-pass/hashmap-memory.rs
View File

@ -34,7 +34,7 @@ mod map_reduce {
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()) );
}
}

2
src/test/run-pass/issue-3424.rs
View File

@ -21,7 +21,7 @@ type rsrc_loader = proc(path: &Path) -> result::Result<~str, ~str>;
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());

12
src/test/run-pass/issue-3609.rs
View File

@ -14,13 +14,11 @@ enum Msg
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));
};
}

2
src/test/run-pass/ivec-tag.rs
View File

@ -8,7 +8,7 @@ fn producer(c: &Chan<~[u8]>) {
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();
}

2
src/test/run-pass/newlambdas-ret-infer.rs
View File

@ -11,7 +11,7 @@
// Test that the lambda kind is inferred correctly as a return
// expression
fn unique() -> proc() { return || (); }
fn unique() -> proc() { return proc() (); }
pub fn main() {
}

2
src/test/run-pass/newlambdas-ret-infer2.rs
View File

@ -11,7 +11,7 @@
// Test that the lambda kind is inferred correctly as a return
// expression
fn unique() -> proc() { || () }
fn unique() -> proc() { proc() () }
pub fn main() {
}

2
src/test/run-pass/operator-overloading.rs
View File

@ -69,6 +69,6 @@ pub fn main() {
assert_eq!(q.y, !(p.y));
// Issue #1733
let result: proc(int) = |_|();
let result: proc(int) = proc(_)();
result(p[true]);
}

4
src/test/run-pass/sendfn-spawn-with-fn-arg.rs
View File

@ -19,12 +19,12 @@ fn test05_start(f: proc(int)) {
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());
});
}

6
src/test/run-pass/spawn-fn.rs
View File

@ -16,9 +16,9 @@ fn x(s: ~str, n: int) {
}
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(); }
}

2
src/test/run-pass/spawn-types.rs
View File

@ -24,5 +24,5 @@ fn iotask(_cx: &ctx, ip: ~str) {
pub fn main() {
let (_p, ch) = stream::<int>();
task::spawn(|| iotask(&ch, ~"localhost") );
task::spawn(proc() iotask(&ch, ~"localhost") );
}

2
src/test/run-pass/spawn.rs
View File

@ -13,7 +13,7 @@ extern mod extra;
use std::task;
pub fn main() {
task::spawn(|| child(10) );
task::spawn(proc() child(10) );
}
fn child(i: int) { error!("{}", i); assert!((i == 10)); }

2
src/test/run-pass/spawn2.rs
View File

@ -10,7 +10,7 @@
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;

2
src/test/run-pass/spawning-with-debug.rs
View File

@ -18,5 +18,5 @@ use std::task;
fn main() {
let mut t = task::task();
t.sched_mode(task::SingleThreaded);
t.spawn(|| ());
t.spawn(proc() ());
}

2
src/test/run-pass/swap-overlapping.rs
View File

@ -18,7 +18,7 @@ pub fn main() {
name: DynTestName(~"test"),
should_fail: false
},
testfn: DynTestFn(|| ()),
testfn: DynTestFn(proc() ()),
};
do_swap(&mut test);
}

2
src/test/run-pass/task-comm-0.rs
View File

@ -29,7 +29,7 @@ fn test05_start(ch : &Chan<int>) {
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();

2
src/test/run-pass/task-comm-1.rs
View File

@ -15,6 +15,6 @@ pub fn main() { test00(); }
fn start() { info!("Started / Finished task."); }
fn test00() {
task::try(|| start() );
task::try(proc() start() );
info!("Completing.");
}

2
src/test/run-pass/task-comm-10.rs
View File

@ -31,7 +31,7 @@ fn start(c: &comm::Chan<comm::Chan<~str>>) {
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");

2
src/test/run-pass/task-comm-11.rs
View File

@ -22,6 +22,6 @@ fn start(c: &comm::Chan<comm::Chan<int>>) {
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();
}

2
src/test/run-pass/task-comm-13.rs
View File

@ -23,6 +23,6 @@ fn start(c: &comm::Chan<int>, start: int, number_of_messages: int) {
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");
}

2
src/test/run-pass/task-comm-14.rs
View File

@ -22,7 +22,7 @@ pub fn main() {
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;
}

2
src/test/run-pass/task-comm-15.rs
View File

@ -29,6 +29,6 @@ pub fn main() {
// 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();
}

2
src/test/run-pass/task-comm-17.rs
View File

@ -20,5 +20,5 @@ fn f() {
}
pub fn main() {
task::spawn(|| f() );
task::spawn(proc() f() );
}

2
src/test/run-pass/task-comm-3.rs
View File

@ -48,7 +48,7 @@ fn test00() {
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;
}

2
src/test/run-pass/task-life-0.rs
View File

@ -13,7 +13,7 @@ extern mod extra;
use std::task;
pub fn main() {
task::spawn(|| child(~"Hello") );
task::spawn(proc() child(~"Hello") );
}
fn child(_s: ~str) {

2
src/test/run-pass/task-spawn-move-and-copy.rs
View File

@ -17,7 +17,7 @@ pub fn main() {
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);
});

6
src/test/run-pass/tempfile.rs
View File

@ -40,7 +40,7 @@ fn test_tempdir() {
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`");
@ -52,7 +52,7 @@ fn test_rm_tempdir() {
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`");
};
@ -61,7 +61,7 @@ fn test_rm_tempdir() {
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");

4
src/test/run-pass/terminate-in-initializer.rs
View File

@ -25,13 +25,13 @@ fn test_ret() { let _x: @int = return; }
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() {

2
src/test/run-pass/threads.rs
View File

@ -14,7 +14,7 @@ use std::task;
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");
}

2
src/test/run-pass/uniq-cc-generic.rs
View File

@ -23,7 +23,7 @@ struct Pointy {
}
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
}

2
src/test/run-pass/uniq-cc.rs
View File

@ -25,7 +25,7 @@ fn empty_pointy() -> @mut Pointy {
return @mut Pointy {
a : none,
c : ~22,
d : || {},
d : proc() {},
}
}

2
src/test/run-pass/unique-send-2.rs
View File

@ -22,7 +22,7 @@ pub fn main() {
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;
}

2
src/test/run-pass/unwind-resource.rs
View File

@ -42,7 +42,7 @@ fn f(c: SharedChan<bool>) {
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());
}