Remove empty argument lists from do expressions

8 files changed, 40 insertions, 40 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index c2b1c61f08f..2258f63b660 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -360,7 +360,7 @@ impl serializer of serialization::serializer for ebml::writer {
     fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
 
     fn emit_vec(len: uint, f: fn()) {
-        do self.wr_tag(es_vec as uint) || {
+        do self.wr_tag(es_vec as uint) {
             self._emit_tagged_uint(es_vec_len, len);
             f()
         }
@@ -487,7 +487,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
         #debug["read_enum_variant()"];
         let idx = self._next_uint(es_enum_vid);
         #debug["  idx=%u", idx];
-        do self.push_doc(self.next_doc(es_enum_body)) || {
+        do self.push_doc(self.next_doc(es_enum_body)) {
             f(idx)
         }
     }
@@ -499,7 +499,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         #debug["read_vec()"];
-        do self.push_doc(self.next_doc(es_vec)) || {
+        do self.push_doc(self.next_doc(es_vec)) {
             let len = self._next_uint(es_vec_len);
             #debug["  len=%u", len];
             f(len)
@@ -554,13 +554,13 @@ fn test_option_int() {
     }
 
     fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
-        do s.emit_enum("core::option::t") || {
+        do s.emit_enum("core::option::t") {
             alt v {
               none {
                 s.emit_enum_variant("core::option::none", 0u, 0u, || { } );
               }
               some(v0) {
-                do s.emit_enum_variant("core::option::some", 1u, 1u) || {
+                do s.emit_enum_variant("core::option::some", 1u, 1u) {
                     s.emit_enum_variant_arg(0u, || serialize_1(s, v0));
                 }
               }
@@ -573,12 +573,12 @@ fn test_option_int() {
     }
 
     fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> {
-        do s.read_enum("core::option::t") || {
+        do s.read_enum("core::option::t") {
             do s.read_enum_variant |i| {
                 alt check i {
                   0u { none }
                   1u {
-                    let v0 = do s.read_enum_variant_arg(0u) || {
+                    let v0 = do s.read_enum_variant_arg(0u) {
                         deserialize_1(s)
                     };
                     some(v0)
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index f847896e934..c29c3349f76 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -305,7 +305,7 @@ value as the `err` variant
 fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
     -> future::future<result::result<(), tcp_err_data>> unsafe {
     let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
-    do future_spawn || {
+    do future_spawn {
         let data_copy = copy(raw_write_data);
         write_common_impl(socket_data_ptr, data_copy)
     }
@@ -397,7 +397,7 @@ read attempt. Pass `0u` to wait indefinitely
 fn read_future(sock: tcp_socket, timeout_msecs: uint)
     -> future::future<result::result<~[u8],tcp_err_data>> {
     let socket_data = ptr::addr_of(*(sock.socket_data));
-    do future_spawn || {
+    do future_spawn {
         read_common_impl(socket_data, timeout_msecs)
     }
 }
@@ -1310,7 +1310,7 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             let actual_req = do comm::listen |server_ch| {
                 run_tcp_test_server(
                     server_ip,
@@ -1379,7 +1379,7 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             let actual_req = do comm::listen |server_ch| {
                 run_tcp_test_server(
                     server_ip,
@@ -1449,7 +1449,7 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             let actual_req = do comm::listen |server_ch| {
                 run_tcp_test_server(
                     server_ip,
@@ -1519,7 +1519,7 @@ mod test {
             |new_conn, kill_ch| {
             log(debug, "SERVER: new connection!");
             do comm::listen |cont_ch| {
-                do task::spawn_sched(task::manual_threads(1u)) || {
+                do task::spawn_sched(task::manual_threads(1u)) {
                     log(debug, "SERVER: starting worker for new req");
 
                     let accept_result = accept(new_conn);
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index a5d56bda0ef..14da0fa86e1 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -84,9 +84,9 @@ iface deserializer {
 // In some cases, these should eventually be coded as traits.
 
 fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
-    do s.emit_vec(vec::len(v)) || {
+    do s.emit_vec(vec::len(v)) {
         do vec::iteri(v) |i,e| {
-            do s.emit_vec_elt(i) || {
+            do s.emit_vec_elt(i) {
                 f(e)
             }
         }
@@ -234,16 +234,16 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
 }
 
 fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
-    do s.emit_enum("option") || {
+    do s.emit_enum("option") {
         alt v {
           none {
-            do s.emit_enum_variant("none", 0u, 0u) || {
+            do s.emit_enum_variant("none", 0u, 0u) {
             }
           }
 
           some(v) {
-            do s.emit_enum_variant("some", 1u, 1u) || {
-                do s.emit_enum_variant_arg(0u) || {
+            do s.emit_enum_variant("some", 1u, 1u) {
+                do s.emit_enum_variant_arg(0u) {
                     st(v)
                 }
             }
@@ -254,7 +254,7 @@ fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
 
 fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
     -> option<T> {
-    do d.read_enum("option") || {
+    do d.read_enum("option") {
         do d.read_enum_variant |i| {
             alt check i {
               0u { // none
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index bbf895840d8..a4acc097ab2 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -390,7 +390,7 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
         ret;
     }
 
-    do task::spawn || {
+    do task::spawn {
         let testfn = copy test.fn;
         let mut builder = task::builder();
         let result_future = task::future_result(builder);
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 15e91691c72..f8440443e6e 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -151,7 +151,7 @@ mod test {
     #[test]
     fn test_gl_timer_sleep_stress1() {
         let hl_loop = uv::global_loop::get();
-        for iter::repeat(200u) || {
+        for iter::repeat(200u) {
             sleep(hl_loop, 1u);
         }
     }
@@ -171,14 +171,14 @@ mod test {
 
         };
 
-        for iter::repeat(repeat) || {
+        for iter::repeat(repeat) {
 
             for spec.each |spec| {
                 let (times, maxms) = spec;
-                do task::spawn || {
+                do task::spawn {
                     import rand::*;
                     let rng = rng();
-                    for iter::repeat(times) || {
+                    for iter::repeat(times) {
                         sleep(hl_loop, rng.next() as uint % maxms);
                     }
                     comm::send(ch, ());
@@ -186,7 +186,7 @@ mod test {
             }
         }
 
-        for iter::repeat(repeat * spec.len()) || {
+        for iter::repeat(repeat * spec.len()) {
             comm::recv(po)
         }
     }
@@ -204,14 +204,14 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        for iter::repeat(times as uint) || {
+        for iter::repeat(times as uint) {
             task::yield();
 
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            do task::spawn() || {
+            do task::spawn() {
                 delayed_send(hl_loop, 1u, test_ch, expected);
             };
 
@@ -231,12 +231,12 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        for iter::repeat(times as uint) || {
+        for iter::repeat(times as uint) {
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            do task::spawn() || {
+            do task::spawn() {
                 delayed_send(hl_loop, 1000u, test_ch, expected);
             };
 
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index d9009aa0503..6384e5b6864 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -191,16 +191,16 @@ mod test {
         let exit_po = comm::port::<()>();
         let exit_ch = comm::chan(exit_po);
         let cycles = 5000u;
-        for iter::repeat(cycles) || {
+        for iter::repeat(cycles) {
             task::spawn_sched(task::manual_threads(1u), || {
                 impl_uv_hl_simple_timer(hl_loop);
                 comm::send(exit_ch, ());
             });
         };
-        for iter::repeat(cycles) || {
+        for iter::repeat(cycles) {
             comm::recv(exit_po);
         };
         log(debug, "test_stress_gl_uv_global_loop_high_level_global_timer"+
             " exiting sucessfully!");
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 27c79d7a6d1..fce69691bde 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -41,7 +41,7 @@ fn spawn_iotask(-builder: task::builder) -> iotask {
 
     do listen |iotask_ch| {
 
-        do run(copy(builder)) || {
+        do run(copy(builder)) {
             #debug("entering libuv task");
             run_loop(iotask_ch);
             #debug("libuv task exiting");
@@ -224,7 +224,7 @@ mod test {
     unsafe fn spawn_test_loop(exit_ch: comm::chan<()>) -> iotask {
         let iotask_port = comm::port::<iotask>();
         let iotask_ch = comm::chan(iotask_port);
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             run_loop(iotask_ch);
             exit_ch.send(());
         };
@@ -255,13 +255,13 @@ mod test {
         // called, at least.
         let work_exit_po = comm::port::<()>();
         let work_exit_ch = comm::chan(work_exit_po);
-        for iter::repeat(7u) || {
-            do task::spawn_sched(task::manual_threads(1u)) || {
+        for iter::repeat(7u) {
+            do task::spawn_sched(task::manual_threads(1u)) {
                 impl_uv_iotask_async(iotask);
                 comm::send(work_exit_ch, ());
             };
         };
-        for iter::repeat(7u) || {
+        for iter::repeat(7u) {
             comm::recv(work_exit_po);
         };
         log(debug, "sending teardown_loop msg..");
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index e282c7c15f4..b302c9103a0 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1473,7 +1473,7 @@ mod test {
         let continue_chan = comm::chan::<bool>(continue_port);
         let continue_chan_ptr = ptr::addr_of(continue_chan);
 
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             impl_uv_tcp_server(bind_ip, port,
                                kill_server_msg,
                                server_resp_msg,
@@ -1486,7 +1486,7 @@ mod test {
         comm::recv(continue_port);
         log(debug, "received on continue port, set up tcp client");
 
-        do task::spawn_sched(task::manual_threads(1u)) || {
+        do task::spawn_sched(task::manual_threads(1u)) {
             impl_uv_tcp_request(request_ip, port,
                                kill_server_msg,
                                ptr::addr_of(client_chan));