update to use new spawn syntax

diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 3ba6a6f7e2e92f4d02ecf5329e65ee8f974e38d9..0ade9b736364ebdbb3bc6603a4838c7902186b4e 100644 (file)
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -31,24 +31,23 @@
 import result::{ok, err};
 
 fn fib(n: int) -> int {
-    fn pfib(args: (chan<int>, int)) {
-        let (c, n) = args;
+    fn pfib(c: chan<int>, n: int) {
         if n == 0 {
             send(c, 0);
         } else if n <= 2 {
             send(c, 1);
         } else {
             let p = port();
-
-            let t1 = task::spawn((chan(p), n - 1), pfib);
-            let t2 = task::spawn((chan(p), n - 2), pfib);
-
+            let ch = chan(p);
+            task::spawn {|| pfib(ch, n - 1); };
+            task::spawn {|| pfib(ch, n - 2); };
             send(c, recv(p) + recv(p));
         }
     }
 
     let p = port();
-    let t = task::spawn((chan(p), n), pfib);
+    let ch = chan(p);
+    let t = task::spawn {|| pfib(ch, n); };
     ret recv(p);
 }
 
@@ -79,7 +78,7 @@ fn stress_task(&&id: int) {
 fn stress(num_tasks: int) {
     let tasks = [];
     range(0, num_tasks) {|i|
-        tasks += [task::spawn_joinable(copy i, stress_task)];
+        tasks += [task::spawn_joinable {|| stress_task(i); }];
     }
     for t in tasks { task::join(t); }
 }

diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index 3b9b9a0a05bfb577f1cea78d3b87a973b58f9b4c..d20c4d72cd0234862a2dda9d042c7855a55bae51 100644 (file)
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -7,7 +7,7 @@
 fn f(&&n: uint) {
     let i = 0u;
     while i < n {
-        task::join(task::spawn_joinable((), g));
+        task::join(task::spawn_joinable {|| g(); });
         i += 1u;
     }
 }
@@ -20,5 +20,5 @@ fn main(args: [str]) {
             10u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
     let i = 0u;
-    while i < n { task::spawn(copy n, f); i += 1u; }
+    while i < n { task::spawn {|| f(n); }; i += 1u; }
 }

diff --git a/src/test/bench/task-perf-vector-party.rs b/src/test/bench/task-perf-vector-party.rs
index b5d7fbf24a060f606092b1e8c56026bb21c9f7a1..000e3670500a44c120032ffd0105866b20dbef0d 100644 (file)
--- a/src/test/bench/task-perf-vector-party.rs
+++ b/src/test/bench/task-perf-vector-party.rs
@@ -21,5 +21,5 @@ fn main(args: [str]) {
         if vec::len(args) < 2u {
             100u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
-    uint::range(0u, 100u) {|i| task::spawn(copy n, f); }
+    uint::range(0u, 100u) {|i| task::spawn {|| f(n); };}
 }

diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index e13603aec91086bcff95e3b625f62aa93dbfc957..1c5b7dc25160f589597b0839ec3f18a5b3ac2f64 100644 (file)
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -79,7 +79,7 @@ fn start_mappers<K1: send, K2: send,
         let tasks = [];
         for i in inputs {
             let m = map, c = ctrl, ii = i;
-            tasks += [task::spawn_joinable(bind map_task(m, c, ii))];
+            tasks += [task::spawn_joinable {|| map_task(m, c, ii)}];
         }
         ret tasks;
     }
@@ -182,10 +182,11 @@ fn map_reduce<K: send1, K: send2,
                   none. {
                     // log(error, "creating new reducer for " + k);
                     let p = port();
+                    let ch = chan(p);
                     let r = reduce, kk = k;
-                    tasks +=
-                        [task::spawn_joinable(bind reduce_task(r, kk,
-                                                               chan(p)))];
+                    tasks += [
+                        task::spawn_joinable {|| reduce_task(r, kk, ch) }
+                    ];
                     c = recv(p);
                     treemap::insert(reducers, k, c);
                   }

diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs
index e517be752e65547ca229de33fb30f1080492855f..42e5145c86223dcd6c0fab4c46c72b22e15f8df9 100644 (file)
--- a/src/test/compile-fail/spawn-non-nil-fn.rs
+++ b/src/test/compile-fail/spawn-non-nil-fn.rs
@@ -3,6 +3,4 @@
 use std;
 import task;
 
-fn f(&&x: int) -> int { ret x; }
-
-fn main() { task::spawn(10, f); }
+fn main() { task::spawn(sendfn() -> int { 10 }); }

diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 0baa9fd9098f26553de9b086dad4b841708dbbce..62ecac925bb0cfa2189812607afd0979b69c9a73 100644 (file)
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -6,10 +6,10 @@
 import comm::port;
 import comm::recv;
 
-fn child(&&_i: ()) { assert (1 == 2); }
+fn child() { assert (1 == 2); }
 
 fn main() {
     let p = port::<int>();
-    task::spawn((), child);
+    task::spawn {|| child(); };
     let x = recv(p);
 }

diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index a52c1fed1ca481e935b1e111a4328516745af62b..5350159475c532b9d9e1213b8b79c853668fe615 100644 (file)
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -7,10 +7,10 @@
 import comm::port;
 import comm::recv;
 
-fn child(&&_i: ()) { fail; }
+fn child() { fail; }
 
 fn main() {
     let p = port::<int>();
-    task::spawn((), child);
+    task::spawn {|| child(); };
     task::yield();
 }

diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index b24c6d8a6cf79e09f5f8cb9f8ce259496e782243..4c807712c65c615f88d8d9caf1be199a133aef6e 100644 (file)
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -6,16 +6,16 @@
 import comm::port;
 import comm::recv;
 
-fn grandchild(&&_i: ()) { fail; }
+fn grandchild() { fail "grandchild dies"; }
 
-fn child(&&_i: ()) {
+fn child() {
     let p = port::<int>();
-    task::spawn((), grandchild);
+    task::spawn {|| grandchild(); };
     let x = recv(p);
 }
 
 fn main() {
     let p = port::<int>();
-    task::spawn((), child);
+    task::spawn {|| child(); };
     let x = recv(p);
 }

diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index ef544778d4318d1a5c95ef63a214efd59d35b803..629cc925749a89498e3cd04e565ceb2b5b3b37fb 100644 (file)
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -6,22 +6,22 @@
 import comm::port;
 import comm::recv;
 
-fn child(&&_args: ()) { assert (1 == 2); }
+fn child() { assert (1 == 2); }
 
-fn parent(&&_args: ()) {
+fn parent() {
     let p = port::<int>();
-    task::spawn((), child);
+    task::spawn {|| child(); };
     let x = recv(p);
 }
 
 // This task is not linked to the failure chain, but since the other
 // tasks are going to fail the kernel, this one will fail too
-fn sleeper(&&_args: ()) {
+fn sleeper() {
     let p = port::<int>();
     let x = recv(p);
 }
 
 fn main() {
-    task::spawn((), sleeper);
-    task::spawn((), parent);
+    task::spawn {|| sleeper(); };
+    task::spawn {|| parent(); };
 }
\ No newline at end of file

diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs
index beb62d72e1d8dc8b263bfb6830ae4c7a858a56bb..60b79ee153706281201351c0a700f1b22c2cd4f4 100644 (file)
--- a/src/test/run-fail/morestack2.rs
+++ b/src/test/run-fail/morestack2.rs
@@ -30,8 +30,8 @@ fn getbig(i: int) {
 }
 
 fn main() {
-    task::spawn((), fn (&&_i: ()) {
+    task::spawn {||
         let r = and_then_get_big_again(());
         getbig_call_c_and_fail(10000);
-    });
+    };
 }
\ No newline at end of file

diff --git a/src/test/run-fail/morestack3.rs b/src/test/run-fail/morestack3.rs
index dd52986c4a40386f96ecc735c7bf9794c80e5504..223f9211307c94739da68f0affd04fb0b6956bee 100644 (file)
--- a/src/test/run-fail/morestack3.rs
+++ b/src/test/run-fail/morestack3.rs
@@ -23,5 +23,7 @@ fn getbig(i: int) {
 }
 
 fn main() {
-    task::spawn(400, getbig_and_fail);
+    task::spawn {||
+        getbig_and_fail(400);
+    };
 }
\ No newline at end of file

diff --git a/src/test/run-fail/morestack4.rs b/src/test/run-fail/morestack4.rs
index 3c85c45e89726a48f89cf6c73e8fab2a7e42062f..b36372d74e1ced0a278367394c627d69ba8685ea 100644 (file)
--- a/src/test/run-fail/morestack4.rs
+++ b/src/test/run-fail/morestack4.rs
@@ -22,5 +22,7 @@ fn getbig_and_fail(&&i: int) {
 
 fn main() {
     rustrt::set_min_stack(256u);
-    task::spawn(1, getbig_and_fail);
+    task::spawn {||
+        getbig_and_fail(1);
+    };
 }
\ No newline at end of file

diff --git a/src/test/run-fail/spawnfail.rs b/src/test/run-fail/spawnfail.rs
index 87cf90fc69d933945983602557405c296e327175..8d342d7fe74d9425c2c05c303ead0493d122611a 100644 (file)
--- a/src/test/run-fail/spawnfail.rs
+++ b/src/test/run-fail/spawnfail.rs
@@ -5,8 +5,8 @@
 
 // We don't want to see any invalid reads
 fn main() {
-    fn f(&&_i: ()) {
+    fn f() {
         fail;
     }
-    task::spawn((), f);
+    task::spawn {|| f(); };
 }
\ No newline at end of file

diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index 314921cdfb7530b68d1362e4a86527c7c5f631c8..50a32ed296ced1b9bdd637ecc94df31eb2b2de8d 100644 (file)
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -4,13 +4,13 @@
 import task;
 import comm;
 
-fn goodfail(&&_i: ()) {
+fn goodfail() {
     task::yield();
     fail "goodfail";
 }
 
 fn main() {
-    task::spawn((), goodfail);
+    task::spawn {|| goodfail(); };
     let po = comm::port();
     // We shouldn't be able to get past this recv since there's no
     // message available