---

yaml
---
r: 90093
b: refs/heads/master
c: 7920772
h: refs/heads/master
i:
  90091: 4dccde9
v: v3

Author: jld

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 18687a92ae6b79eb221706db7b7390330b2f7a21
+refs/heads/master: 792077274cb02894e059c6cc73b998223e549cbb
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/doc/po/ja/rust.md.po

@@ -5383,7 +5383,7 @@ msgstr ""
 #. type: Plain text
 #: doc/rust.md:2849
 msgid ""
-"type Binop<'self> = 'self |int,int| -> int; let bo: Binop = add; x = "
+"type Binop<'self> = &'self fn(int,int) -> int; let bo: Binop = add; x = "
 "bo(5,7); ~~~~~~~~"
 msgstr ""
 

trunk/doc/po/rust.md.pot

@@ -5370,7 +5370,7 @@ msgstr ""
 #. type: Plain text
 #: doc/rust.md:2849
 msgid ""
-"type Binop<'self> = 'self |int,int| -> int; let bo: Binop = add; x = "
+"type Binop<'self> = &'self fn(int,int) -> int; let bo: Binop = add; x = "
 "bo(5,7); ~~~~~~~~"
 msgstr ""
 

trunk/doc/rust.md

@@ -1754,8 +1754,6 @@ names are effectively reserved. Some significant attributes include:
 * The `deriving` attribute, for automatically generating
   implementations of certain traits.
 * The `static_assert` attribute, for asserting that a static bool is true at compiletime
-* The `thread_local` attribute, for defining a `static mut` as a thread-local. Note that this is
-  only a low-level building block, and is not local to a *task*, nor does it provide safety.
 
 Other attributes may be added or removed during development of the language.
 
@@ -2705,27 +2703,33 @@ 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 invoking a function and passing it a newly-created a procedure.
+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.
 
-The optional `ident_list` and `block` provided in a `do` expression are parsed
-as though they constitute a procedure expression;
+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;
 if the `ident_list` is missing, an empty `ident_list` is implied.
 
-The procedure expression is then provided as a _trailing argument_
-to the outermost [call](#call-expressions) or
-[method call](#method-call-expressions) expression
+The lambda 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: proc(int)) { }
+# fn f(f: |int|) { }
 # fn g(i: int) { }
 
-f(proc(j) { g(j) });
+f(|j| g(j));
 
 do f |j| {
     g(j);
@@ -2735,10 +2739,10 @@ do f |j| {
 In this example, both calls to the (binary) function `k` are equivalent:
 
 ~~~~
-# fn k(x:int, f: proc(int)) { }
+# fn k(x:int, f: |int|) { }
 # fn l(i: int) { }
 
-k(3, proc(j) { l(j) });
+k(3, |j| l(j));
 
 do k(3) |j| {
    l(j);
@@ -3190,7 +3194,7 @@ fn add(x: int, y: int) -> int {
 
 let mut x = add(5,7);
 
-type Binop<'self> = 'self |int,int| -> int;
+type Binop<'self> = &'self fn(int,int) -> int;
 let bo: Binop = add;
 x = bo(5,7);
 ~~~~

trunk/doc/tutorial-conditions.md

@@ -457,15 +457,15 @@ condition! {
 
 fn main() {
     // Trap the condition:
-    malformed_line::cond.trap(|_| (-1,-1)).inside(|| {
+    do 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`
-    malformed_line::cond.trap(|_| None).inside(|| {
+    do 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`
-    malformed_line::cond.trap(|_| UsePreviousLine).inside(|| {
+    do 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
-    malformed_int::cond.trap(|_| -1).inside(|| {
+    do malformed_int::cond.trap(|_| -1).inside {
 
         // Trap the `malformed_line` condition and return `UsePreviousLine`
-        malformed_line::cond.trap(|_| UsePreviousLine).inside(|| {
+        do 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

trunk/doc/tutorial-tasks.md

@@ -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(proc() println("I am also running in a different task!") );
+spawn( || println("I am also running in a different task!") );
 
 // The canonical way to spawn is using `do` notation
 do spawn {
@@ -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 = vec::from_fn(3, |init_val| {
+let ports = do 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() );
@@ -278,7 +278,7 @@ fn fib(n: u64) -> u64 {
     12586269025
 }
 
-let mut delayed_fib = extra::future::Future::spawn(proc() fib(50));
+let mut delayed_fib = extra::future::Future::spawn (|| fib(50) );
 make_a_sandwich();
 println!("fib(50) = {:?}", delayed_fib.get())
 ~~~

trunk/doc/tutorial.md

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

trunk/src/compiletest/compiletest.rs

@@ -266,12 +266,12 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
         let file = file.clone();
         debug!("inspecting file {}", file.display());
         if is_test(config, &file) {
-            let t = make_test(config, &file, || {
+            let t = do make_test(config, &file) {
                 match config.mode {
                     mode_codegen => make_metrics_test_closure(config, &file),
                     _ => make_test_closure(config, &file)
                 }
-            });
+            };
             tests.push(t)
         }
     }
@@ -301,8 +301,8 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
     return valid;
 }
 
-pub fn make_test(config: &config, testfile: &Path, f: || -> test::TestFn)
-                 -> test::TestDescAndFn {
+pub fn make_test(config: &config, testfile: &Path,
+                 f: &fn()->test::TestFn) -> test::TestDescAndFn {
     test::TestDescAndFn {
         desc: test::TestDesc {
             name: make_test_name(config, testfile),
@@ -333,15 +333,13 @@ 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(proc() { runtest::run(config.take(), testfile.take()) })
+    test::DynTestFn(|| { runtest::run(config.take(), testfile.take()) })
 }
 
 pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::TestFn {
     use std::cell::Cell;
     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(proc(mm) {
-        runtest::run_metrics(config.take(), testfile.take(), mm)
-    })
+    test::DynMetricFn(|mm| { runtest::run_metrics(config.take(), testfile.take(), mm) })
 }

trunk/src/compiletest/header.rs

@@ -39,7 +39,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pp_exact = None;
     let mut debugger_cmds = ~[];
     let mut check_lines = ~[];
-    iter_header(testfile, |ln| {
+    do iter_header(testfile) |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
           None => ()
@@ -74,7 +74,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         };
 
         true
-    });
+    };
     return TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
@@ -91,18 +91,18 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
         ~"xfail-" + util::get_os(config.target)
     }
 
-    let val = iter_header(testfile, |ln| {
+    let val = do iter_header(testfile) |ln| {
         if parse_name_directive(ln, "xfail-test") { false }
         else if parse_name_directive(ln, xfail_target(config)) { false }
         else if config.mode == common::mode_pretty &&
             parse_name_directive(ln, "xfail-pretty") { false }
         else { true }
-    });
+    };
 
     !val
 }
 
-fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
+fn iter_header(testfile: &Path, it: &fn(&str) -> bool) -> bool {
     use std::io::buffered::BufferedReader;
     use std::io::File;
 
@@ -143,7 +143,7 @@ fn parse_check_line(line: &str) -> Option<~str> {
 }
 
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
-    parse_name_value_directive(line, ~"exec-env").map(|nv| {
+    do parse_name_value_directive(line, ~"exec-env").map |nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: ~[~str] = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
 
@@ -155,7 +155,7 @@ fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
           }
           n => fail!("Expected 1 or 2 strings, not {}", n)
         }
-    })
+    }
 }
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {

trunk/src/compiletest/procsrv.rs

@@ -22,11 +22,11 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
     assert!(prog.ends_with(".exe"));
     let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
 
-    env = env.map(|pair| {
+    env = do env.map() |pair| {
         let (k,v) = (*pair).clone();
         if k == ~"PATH" { (~"PATH", v + ";" + lib_path + ";" + aux_path) }
         else { (k,v) }
-    });
+    };
     if prog.ends_with("rustc.exe") {
         env.push((~"RUST_THREADS", ~"1"));
     }