test: Remove all remaining non-procedure uses of do.

Author: pcwalton

doc/rust.md

@@ -2703,33 +2703,27 @@ A `loop` expression is only permitted in the body of a loop.
 do_expr : "do" expr [ '|' ident_list '|' ] ? '{' block '}' ;
 ~~~~
 
-A _do expression_ provides a more-familiar block-syntax for a [lambda expression](#lambda-expressions),
-including a special translation of [return expressions](#return-expressions) inside the supplied block.
-
-Any occurrence of a [return expression](#return-expressions)
-inside this `block` expression is rewritten
-as a reference to an (anonymous) flag set in the caller's environment,
-which is checked on return from the `expr` and, if set,
-causes a corresponding return from the caller.
-In this way, the meaning of `return` statements in language built-in control blocks is preserved,
-if they are rewritten using lambda functions and `do` expressions as abstractions.
-
-The optional `ident_list` and `block` provided in a `do` expression are parsed as though they constitute a lambda expression;
+A _do expression_ provides a more-familiar block syntax
+for invoking a function and passing it a newly-created a procedure.
+
+The optional `ident_list` and `block` provided in a `do` expression are parsed
+as though they constitute a procedure expression;
 if the `ident_list` is missing, an empty `ident_list` is implied.
 
-The lambda expression is then provided as a _trailing argument_
-to the outermost [call](#call-expressions) or [method call](#method-call-expressions) expression
+The procedure expression is then provided as a _trailing argument_
+to the outermost [call](#call-expressions) or
+[method call](#method-call-expressions) expression
 in the `expr` following `do`.
 If the `expr` is a [path expression](#path-expressions), it is parsed as though it is a call expression.
 If the `expr` is a [field expression](#field-expressions), it is parsed as though it is a method call expression.
 
 In this example, both calls to `f` are equivalent:
 
 ~~~~
-# fn f(f: |int|) { }
+# fn f(f: proc(int)) { }
 # fn g(i: int) { }
 
-f(|j| g(j));
+f(proc(j) { g(j) });
 
 do f |j| {
     g(j);
@@ -2739,10 +2733,10 @@ do f |j| {
 In this example, both calls to the (binary) function `k` are equivalent:
 
 ~~~~
-# fn k(x:int, f: |int|) { }
+# fn k(x:int, f: proc(int)) { }
 # fn l(i: int) { }
 
-k(3, |j| l(j));
+k(3, proc(j) { l(j) });
 
 do k(3) |j| {
    l(j);

doc/tutorial-conditions.md

@@ -457,15 +457,15 @@ condition! {
 
 fn main() {
     // Trap the condition:
-    do malformed_line::cond.trap(|_| (-1,-1)).inside {
+    malformed_line::cond.trap(|_| (-1,-1)).inside(|| {
 
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
                 println!("{:4.4d}, {:4.4d}", a, b);
         }
 
-    }
+    })
 }
 
 fn read_int_pairs() -> ~[(int,int)] {
@@ -535,15 +535,15 @@ condition! {
 
 fn main() {
     // Trap the condition and return `None`
-    do malformed_line::cond.trap(|_| None).inside {
+    malformed_line::cond.trap(|_| None).inside(|| {
 
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
             println!("{:4.4d}, {:4.4d}", a, b);
         }
 
-    }
+    })
 }
 
 fn read_int_pairs() -> ~[(int,int)] {
@@ -631,15 +631,15 @@ condition! {
 
 fn main() {
     // Trap the condition and return `UsePreviousLine`
-    do malformed_line::cond.trap(|_| UsePreviousLine).inside {
+    malformed_line::cond.trap(|_| UsePreviousLine).inside(|| {
 
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
             println!("{:4.4d}, {:4.4d}", a, b);
         }
 
-    }
+    })
 }
 
 fn read_int_pairs() -> ~[(int,int)] {
@@ -758,19 +758,19 @@ condition! {
 
 fn main() {
     // Trap the `malformed_int` condition and return -1
-    do malformed_int::cond.trap(|_| -1).inside {
+    malformed_int::cond.trap(|_| -1).inside(|| {
 
         // Trap the `malformed_line` condition and return `UsePreviousLine`
-        do malformed_line::cond.trap(|_| UsePreviousLine).inside {
+        malformed_line::cond.trap(|_| UsePreviousLine).inside(|| {
 
             // The protected logic.
             let pairs = read_int_pairs();
             for &(a,b) in pairs.iter() {
                 println!("{:4.4d}, {:4.4d}", a, b);
             }
 
-        }
-    }
+        })
+    })
 }
 
 // Parse an int; if parsing fails, call the condition handler and

doc/tutorial-tasks.md

@@ -253,13 +253,13 @@ might look like the example below.
 # use std::vec;
 
 // Create a vector of ports, one for each child task
-let ports = do vec::from_fn(3) |init_val| {
+let ports = vec::from_fn(3, |init_val| {
     let (port, chan) = stream();
     do spawn {
         chan.send(some_expensive_computation(init_val));
     }
     port
-};
+});
 
 // Wait on each port, accumulating the results
 let result = ports.iter().fold(0, |accum, port| accum + port.recv() );

doc/tutorial.md

@@ -1439,19 +1439,14 @@ call_twice(function);
 
 ## Do syntax
 
-The `do` expression provides a way to treat higher-order functions
-(functions that take closures as arguments) as control structures.
+The `do` expression makes it easier to call functions that take procedures
+as arguments.
 
-Consider this function that iterates over a vector of
-integers, passing in a pointer to each integer in the vector:
+Consider this function that takes a procedure:
 
 ~~~~
-fn each(v: &[int], op: |v: &int|) {
-   let mut n = 0;
-   while n < v.len() {
-       op(&v[n]);
-       n += 1;
-   }
+fn call_it(op: proc(v: int)) {
+    op(10)
 }
 ~~~~
 
@@ -1460,26 +1455,24 @@ argument, we can write it in a way that has a pleasant, block-like
 structure.
 
 ~~~~
-# fn each(v: &[int], op: |v: &int|) { }
-# fn do_some_work(i: &int) { }
-each([1, 2, 3], |n| {
-    do_some_work(n);
+# fn call_it(op: proc(v: int)) { }
+call_it(proc(n) {
+    println(n.to_str());
 });
 ~~~~
 
 This is such a useful pattern that Rust has a special form of function
-call that can be written more like a built-in control structure:
+call for these functions.
 
 ~~~~
-# fn each(v: &[int], op: |v: &int|) { }
-# fn do_some_work(i: &int) { }
-do each([1, 2, 3]) |n| {
-    do_some_work(n);
+# fn call_it(op: proc(v: int)) { }
+do call_it() |n| {
+    println(n.to_str());
 }
 ~~~~
 
 The call is prefixed with the keyword `do` and, instead of writing the
-final closure inside the argument list, it appears outside of the
+final procedure inside the argument list, it appears outside of the
 parentheses, where it looks more like a typical block of
 code.
 

src/libextra/arena.rs

@@ -297,14 +297,14 @@ fn test_arena_destructors_fail() {
     for i in range(0u, 10) {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
-        do arena.alloc { @i };
+        arena.alloc(|| { @i });
         // Allocate something with funny size and alignment, to keep
         // things interesting.
-        do arena.alloc { [0u8, 1u8, 2u8] };
+        arena.alloc(|| { [0u8, 1u8, 2u8] });
     }
     // Now, fail while allocating
-    do arena.alloc::<@int> {
+    arena.alloc::<@int>(|| {
         // Now fail.
         fail!();
-    };
+    });
 }

src/libextra/base64.rs

@@ -317,20 +317,20 @@ mod test {
         use std::rand::{task_rng, random, Rng};
         use std::vec;
 
-        do 1000.times {
+        1000.times(|| {
             let times = task_rng().gen_range(1u, 100);
             let v = vec::from_fn(times, |_| random::<u8>());
             assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
-        }
+        })
     }
 
     #[bench]
     pub fn bench_to_base64(bh: & mut BenchHarness) {
         let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
                  ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-        do bh.iter {
+        bh.iter(|| {
             s.as_bytes().to_base64(STANDARD);
-        }
+        });
         bh.bytes = s.len() as u64;
     }
 
@@ -339,9 +339,9 @@ mod test {
         let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
                  ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
         let b = s.as_bytes().to_base64(STANDARD);
-        do bh.iter {
+        bh.iter(|| {
             b.from_base64();
-        }
+        });
         bh.bytes = b.len() as u64;
     }