---

yaml
---
r: 5867
b: refs/heads/master
c: ac671c3
h: refs/heads/master
i:
  5865: e5b4836
  5863: 92da217
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4341e50e3a115c00474ecae24b6e1c45fd00cfeb
+refs/heads/master: ac671c31725b5bd42ad902195ac74f16c3c6c1ad

trunk/src/test/bench/shootout-pfib.rs

@@ -27,23 +27,24 @@ import std::comm::send;
 import std::comm::recv;
 
 fn fib(n: int) -> int {
-    fn pfib(c: chan<int>, n: int) {
+    fn# pfib(args: (chan<int>, int)) {
+        let (c, n) = args;
         if n == 0 {
             send(c, 0);
         } else if n <= 2 {
             send(c, 1);
         } else {
             let p = port();
 
-            let t1 = task::spawn(bind pfib(chan(p), n - 1));
-            let t2 = task::spawn(bind pfib(chan(p), n - 2));
+            let t1 = task::spawn2((chan(p), n - 1), pfib);
+            let t2 = task::spawn2((chan(p), n - 2), pfib);
 
             send(c, recv(p) + recv(p));
         }
     }
 
     let p = port();
-    let t = task::spawn(bind pfib(chan(p), n));
+    let t = task::spawn2((chan(p), n), pfib);
     ret recv(p);
 }
 
@@ -61,7 +62,7 @@ fn parse_opts(argv: [str]) -> config {
     }
 }
 
-fn stress_task(id: int) {
+fn# stress_task(&&id: int) {
     let i = 0;
     while true {
         let n = 15;
@@ -74,7 +75,7 @@ fn stress_task(id: int) {
 fn stress(num_tasks: int) {
     let tasks = [];
     for each i: int in range(0, num_tasks) {
-        tasks += [task::spawn_joinable(bind stress_task(i))];
+        tasks += [task::spawn_joinable2(copy i, stress_task)];
     }
     for t in tasks { task::join(t); }
 }

trunk/src/test/bench/task-perf-spawnalot.rs

@@ -4,22 +4,21 @@ import std::task;
 import std::uint;
 import std::str;
 
-fn f(n: uint) {
+fn# f(&&n: uint) {
     let i = 0u;
     while i < n {
-        let thunk = g;
-        task::join(task::spawn_joinable(thunk));
+        task::join(task::spawn_joinable2((), g));
         i += 1u;
     }
 }
 
-fn g() { }
+fn# g(&&_i: ()) { }
 
 fn main(args: [str]) {
     let n =
         if vec::len(args) < 2u {
             10u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
     let i = 0u;
-    while i < n { task::spawn(bind f(n)); i += 1u; }
+    while i < n { task::spawn2(copy n, f); i += 1u; }
 }

trunk/src/test/bench/task-perf-vector-party.rs

@@ -9,7 +9,7 @@ import std::uint;
 import std::str;
 import std::task;
 
-fn f(n: uint) {
+fn# f(&&n: uint) {
     for each i in uint::range(0u, n) {
         let v: [u8] = [];
         vec::reserve(v, 1000u);
@@ -21,5 +21,5 @@ fn main(args: [str]) {
         if vec::len(args) < 2u {
             100u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
-    for each i in uint::range(0u, 100u) { task::spawn(bind f(n)); }
+    for each i in uint::range(0u, 100u) { task::spawn2(copy n, f); }
 }

trunk/src/test/bench/task-perf-word-count.rs

@@ -70,12 +70,13 @@ mod map_reduce {
        [joinable_task] {
         let tasks = [];
         for i: str in inputs {
-            tasks += [task::spawn_joinable(bind map_task(ctrl, i))];
+            tasks += [task::spawn_joinable2((ctrl, i), map_task)];
         }
         ret tasks;
     }
 
-    fn map_task(ctrl: chan<ctrl_proto>, input: str) {
+    fn# map_task(args: (chan<ctrl_proto>, str)) {
+        let (ctrl, input) = args;
         // log_err "map_task " + input;
         let intermediates = map::new_str_hash();
 
@@ -107,7 +108,8 @@ mod map_reduce {
         send(ctrl, mapper_done);
     }
 
-    fn reduce_task(key: str, out: chan<chan<reduce_proto>>) {
+    fn# reduce_task(args: (str, chan<chan<reduce_proto>>)) {
+        let (key, out) = args;
         let p = port();
 
         send(out, chan(p));
@@ -169,7 +171,7 @@ mod map_reduce {
                     // log_err "creating new reducer for " + k;
                     let p = port();
                     tasks +=
-                        [task::spawn_joinable(bind reduce_task(k, chan(p)))];
+                        [task::spawn_joinable2((k, chan(p)), reduce_task)];
                     c = recv(p);
                     reducers.insert(k, c);
                   }

trunk/src/test/compile-fail/spawn-non-nil-fn.rs

@@ -3,6 +3,6 @@
 use std;
 import std::task;
 
-fn f(x: int) -> int { ret x; }
+fn# f(&&x: int) -> int { ret x; }
 
-fn main() { task::spawn(bind f(10)); }
+fn main() { task::spawn2(10, f); }

trunk/src/test/run-fail/linked-failure.rs

@@ -6,11 +6,10 @@ import std::task;
 import std::comm::port;
 import std::comm::recv;
 
-fn child() { assert (1 == 2); }
+fn# child(&&_i: ()) { assert (1 == 2); }
 
 fn main() {
     let p = port::<int>();
-    let f = child;
-    task::spawn(f);
+    task::spawn2((), child);
     let x = recv(p);
 }

trunk/src/test/run-fail/linked-failure2.rs

@@ -7,11 +7,10 @@ import std::comm::chan;
 import std::comm::port;
 import std::comm::recv;
 
-fn child() { fail; }
+fn# child(&&_i: ()) { fail; }
 
 fn main() {
     let p = port::<int>();
-    let f = child;
-    task::spawn(f);
+    task::spawn2((), child);
     task::yield();
 }

trunk/src/test/run-fail/linked-failure3.rs

@@ -6,18 +6,16 @@ import std::task;
 import std::comm::port;
 import std::comm::recv;
 
-fn grandchild() { fail; }
+fn# grandchild(&&_i: ()) { fail; }
 
-fn child() {
+fn# child(&&_i: ()) {
     let p = port::<int>();
-    let f = grandchild;
-    task::spawn(f);
+    task::spawn2((), grandchild);
     let x = recv(p);
 }
 
 fn main() {
     let p = port::<int>();
-    let f = child;
-    task::spawn(f);
+    task::spawn2((), child);
     let x = recv(p);
 }

trunk/src/test/run-fail/task-comm-recv-block.rs

@@ -4,13 +4,13 @@ use std;
 import std::task;
 import std::comm;
 
-fn goodfail() {
+fn# goodfail(&&_i: ()) {
     task::yield();
     fail "goodfail";
 }
 
 fn main() {
-    task::spawn(bind goodfail());
+    task::spawn2((), goodfail);
     let po = comm::port();
     // We shouldn't be able to get past this recv since there's no
     // message available

trunk/src/test/run-pass/basic-1.rs

@@ -7,12 +7,12 @@ import std::comm::send;
 import std::comm::recv;
 import std::task;
 
-fn a(c: chan<int>) { send(c, 10); }
+fn# a(c: chan<int>) { send(c, 10); }
 
 fn main() {
     let p = port();
-    task::spawn(bind a(chan(p)));
-    task::spawn(bind b(chan(p)));
+    task::spawn2(chan(p), a);
+    task::spawn2(chan(p), a);
     let n: int = 0;
     n = recv(p);
     n = recv(p);

trunk/src/test/run-pass/basic-2.rs

@@ -7,19 +7,19 @@ import std::comm::chan;
 import std::comm::recv;
 import std::task;
 
-fn a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
+fn# a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
 
 fn main() {
     let p = comm::port();
-    task::spawn(bind a(chan(p)));
-    task::spawn(bind b(chan(p)));
+    task::spawn2(chan(p), a);
+    task::spawn2(chan(p), b);
     let n: int = 0;
     n = recv(p);
     n = recv(p);
     log "Finished.";
 }
 
-fn b(c: chan<int>) {
+fn# b(c: chan<int>) {
     log "task b0";
     log "task b1";
     log "task b2";

trunk/src/test/run-pass/basic.rs

@@ -7,7 +7,7 @@ import std::comm::chan;
 import std::comm::recv;
 import std::task;
 
-fn a(c: chan<int>) {
+fn# a(c: chan<int>) {
     if true {
         log "task a";
         log "task a";
@@ -26,8 +26,8 @@ fn main() {
     let n: int = 2 + 3 * 7;
     let s: str = "hello there";
     let p = comm::port();
-    task::spawn(bind a(chan(p)));
-    task::spawn(bind b(chan(p)));
+    task::spawn2(chan(p), a);
+    task::spawn2(chan(p), b);
     let x: int = 10;
     x = g(n, s);
     log x;
@@ -37,7 +37,7 @@ fn main() {
     log "children finished, root finishing";
 }
 
-fn b(c: chan<int>) {
+fn# b(c: chan<int>) {
     if true {
         log "task b";
         log "task b";

trunk/src/test/run-pass/binops.rs

@@ -87,10 +87,10 @@ fn test_ptr() {
 }
 
 fn test_task() {
-    fn f() { }
+    fn# f(&&_i: ()) { }
     let f1 = f, f2 = f;
-    let t1 = task::spawn(f1);
-    let t2 = task::spawn(f2);
+    let t1 = task::spawn2((), f1);
+    let t2 = task::spawn2((), f2);
 
     assert (t1 == t1);
     assert (t1 != t2);

trunk/src/test/run-pass/chan-leak.rs

@@ -12,7 +12,7 @@ tag request { quit; close(chan<bool>); }
 
 type ctx = chan<request>;
 
-fn request_task(c: chan<ctx>) {
+fn# request_task(c: chan<ctx>) {
     let p = port();
     send(c, chan(p));
     let req: request;
@@ -23,7 +23,7 @@ fn request_task(c: chan<ctx>) {
 
 fn new() -> ctx {
     let p = port();
-    let t = task::spawn(bind request_task(chan(p)));
+    let t = task::spawn2(chan(p), request_task);
     let cx: ctx;
     cx = recv(p);
     ret cx;

trunk/src/test/run-pass/child-outlives-parent.rs

@@ -3,6 +3,6 @@
 use std;
 import std::task;
 
-fn child2(-s: str) { }
+fn# child2(&&s: str) { }
 
-fn main() { let x = task::spawn(bind child2("hi")); }
+fn main() { let x = task::spawn2("hi", child2); }

trunk/src/test/run-pass/comm.rs

@@ -9,14 +9,14 @@ import std::task;
 
 fn main() {
     let p = comm::port();
-    let t = task::spawn(bind child(chan(p)));
+    let t = task::spawn2(chan(p), child);
     let y = recv(p);
     log_err "received";
     log_err y;
     assert (y == 10);
 }
 
-fn child(c: chan<int>) {
+fn# child(c: chan<int>) {
     log_err "sending";
     send(c, 10);
     log_err "value sent"

trunk/src/test/run-pass/hashmap-memory.rs

@@ -33,10 +33,11 @@ mod map_reduce {
     tag ctrl_proto { find_reducer([u8], chan<int>); mapper_done; }
 
     fn start_mappers(ctrl: chan<ctrl_proto>, inputs: [str]) {
-        for i: str in inputs { task::spawn(bind map_task(ctrl, i)); }
+        for i: str in inputs { task::spawn2((ctrl, i), map_task); }
     }
 
-    fn map_task(ctrl: chan<ctrl_proto>, -input: str) {
+    fn# map_task(&&args: (chan<ctrl_proto>, str)) {
+        let (ctrl, input) = args;
 
         let intermediates = map::new_str_hash();
 

trunk/src/test/run-pass/issue-506.rs

@@ -9,6 +9,6 @@ native "rust" mod rustrt {
     fn task_yield();
 }
 
-fn yield_wrap() unsafe { rustrt::task_yield(); }
+fn# yield_wrap(&&_i: ()) unsafe { rustrt::task_yield(); }
 
-fn main() { let f = yield_wrap; task::spawn(f); }
+fn main() { task::spawn2((), yield_wrap); }

trunk/src/test/run-pass/issue-507.rs

@@ -15,17 +15,17 @@ import std::comm::send;
 import std::comm::port;
 import std::comm::recv;
 
-fn grandchild(c: chan<int>) { send(c, 42); }
+fn# grandchild(c: chan<int>) { send(c, 42); }
 
-fn child(c: chan<int>) {
-    let _grandchild = task::spawn_joinable(bind grandchild(c));
+fn# child(c: chan<int>) {
+    let _grandchild = task::spawn_joinable2(c, grandchild);
     join(_grandchild);
 }
 
 fn main() {
     let p = comm::port();
 
-    let _child = task::spawn_joinable(bind child(chan(p)));
+    let _child = task::spawn_joinable2(chan(p), child);
 
     let x: int = recv(p);