---

yaml
---
r: 34784
b: refs/heads/master
c: 32baf1c
h: refs/heads/master
v: v3

Author: killerswan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b532a8e5856d525bb7121f4bc00603b91bc2cc5d
+refs/heads/master: 32baf1c54c4214f5a50da53979008ef9bcdad359
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024

trunk/doc/tutorial-tasks.md

@@ -161,7 +161,7 @@ use pipes::{stream, Port, Chan};
 
 let (chan, port): (Chan<int>, Port<int>) = stream();
 
-do spawn |move chan| {
+do spawn {
     let result = some_expensive_computation();
     chan.send(result);
 }
@@ -192,7 +192,7 @@ spawns the child task.
 # use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
 # let (chan, port) = stream();
-do spawn |move chan| {
+do spawn {
     let result = some_expensive_computation();
     chan.send(result);
 }
@@ -229,7 +229,7 @@ following program is ill-typed:
 # fn some_expensive_computation() -> int { 42 }
 let (chan, port) = stream();
 
-do spawn |move chan| {
+do spawn {
     chan.send(some_expensive_computation());
 }
 
@@ -253,7 +253,7 @@ let chan = SharedChan(move chan);
 for uint::range(0, 3) |init_val| {
     // Create a new channel handle to distribute to the child task
     let child_chan = chan.clone();
-    do spawn |move child_chan| {
+    do spawn {
         child_chan.send(some_expensive_computation(init_val));
     }
 }
@@ -283,10 +283,10 @@ might look like the example below.
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
     let (chan, port) = stream();
-    do spawn |move chan| {
+    do spawn {
         chan.send(some_expensive_computation(init_val));
     }
-    move port
+    port
 };
 
 // Wait on each port, accumulating the results
@@ -398,13 +398,13 @@ before returning. Hence:
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 let (sender, receiver): (Chan<int>, Port<int>) = stream();
-do spawn |move receiver| {  // Bidirectionally linked
+do spawn {  // Bidirectionally linked
     // Wait for the supervised child task to exist.
     let message = receiver.recv();
     // Kill both it and the parent task.
     assert message != 42;
 }
-do try |move sender| {  // Unidirectionally linked
+do try {  // Unidirectionally linked
     sender.send(42);
     sleep_forever();  // Will get woken up by force
 }
@@ -505,7 +505,7 @@ Here is the code for the parent task:
 
 let (from_child, to_child) = DuplexStream();
 
-do spawn |move to_child| {
+do spawn || {
     stringifier(&to_child);
 };
 

trunk/doc/tutorial.md

@@ -1502,9 +1502,9 @@ and [`core::str`]. Here are some examples.
 # fn unwrap_crayon(c: Crayon) -> int { 0 }
 # fn eat_crayon_wax(i: int) { }
 # fn store_crayon_in_nasal_cavity(i: uint, c: Crayon) { }
-# fn crayon_to_str(c: Crayon) -> &str { "" }
+# fn crayon_to_str(c: Crayon) -> ~str { ~"" }
 
-let crayons = [Almond, AntiqueBrass, Apricot];
+let crayons = &[Almond, AntiqueBrass, Apricot];
 
 // Check the length of the vector
 assert crayons.len() == 3;
@@ -1569,7 +1569,7 @@ let bloop = |well, oh: mygoodness| -> what_the { fail oh(well) };
 ~~~~
 
 There are several forms of closure, each with its own role. The most
-common, called a _stack closure_, has type `&fn` and can directly
+common, called a _stack closure_, has type `fn&` and can directly
 access local variables in the enclosing scope.
 
 ~~~~
@@ -1591,7 +1591,7 @@ pervasively in Rust code.
 When you need to store a closure in a data structure, a stack closure
 will not do, since the compiler will refuse to let you store it. For
 this purpose, Rust provides a type of closure that has an arbitrary
-lifetime, written `@fn` (boxed closure, analogous to the `@` pointer
+lifetime, written `fn@` (boxed closure, analogous to the `@` pointer
 type described earlier). This type of closure *is* first-class.
 
 A managed closure does not directly access its environment, but merely
@@ -1604,9 +1604,8 @@ returns it from a function, and then calls it:
 
 ~~~~
 # extern mod std;
-fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
-    // The compiler knows that we intend this closure to be of type @fn
-    return |s| s + suffix;
+fn mk_appender(suffix: ~str) -> fn@(~str) -> ~str {
+    return fn@(s: ~str) -> ~str { s + suffix };
 }
 
 fn main() {
@@ -1615,9 +1614,22 @@ fn main() {
 }
 ~~~~
 
+This example uses the long closure syntax, `fn@(s: ~str) ...`. Using
+this syntax makes it explicit that we are declaring a boxed
+closure. In practice, boxed closures are usually defined with the
+short closure syntax introduced earlier, in which case the compiler
+infers the type of closure. Thus our managed closure example could
+also be written:
+
+~~~~
+fn mk_appender(suffix: ~str) -> fn@(~str) -> ~str {
+    return |s| s + suffix;
+}
+~~~~
+
 ## Owned closures
 
-Owned closures, written `~fn` in analogy to the `~` pointer type,
+Owned closures, written `fn~` in analogy to the `~` pointer type,
 hold on to things that can safely be sent between
 processes. They copy the values they close over, much like managed
 closures, but they also own them: that is, no other code can access
@@ -1637,10 +1649,12 @@ callers may pass any kind of closure.
 
 ~~~~
 fn call_twice(f: fn()) { f(); f(); }
-let closure = || { "I'm a closure, and it doesn't matter what type I am"; };
-fn function() { "I'm a normal function"; }
-call_twice(closure);
-call_twice(function);
+call_twice(|| { ~"I am an inferred stack closure"; } );
+call_twice(fn&() { ~"I am also a stack closure"; } );
+call_twice(fn@() { ~"I am a managed closure"; });
+call_twice(fn~() { ~"I am an owned closure"; });
+fn bare_function() { ~"I am a plain function"; }
+call_twice(bare_function);
 ~~~~
 
 > ***Note:*** Both the syntax and the semantics will be changing
@@ -1679,7 +1693,7 @@ structure.
 ~~~~
 # fn each(v: &[int], op: fn(v: &int)) { }
 # fn do_some_work(i: &int) { }
-each([1, 2, 3], |n| {
+each(&[1, 2, 3], |n| {
     do_some_work(n);
 });
 ~~~~
@@ -1690,7 +1704,7 @@ call that can be written more like a built-in control structure:
 ~~~~
 # fn each(v: &[int], op: fn(v: &int)) { }
 # fn do_some_work(i: &int) { }
-do each([1, 2, 3]) |n| {
+do each(&[1, 2, 3]) |n| {
     do_some_work(n);
 }
 ~~~~
@@ -1701,7 +1715,7 @@ parentheses, where it looks more like a typical block of
 code.
 
 `do` is a convenient way to create tasks with the `task::spawn`
-function.  `spawn` has the signature `spawn(fn: ~fn())`. In other
+function.  `spawn` has the signature `spawn(fn: fn~())`. In other
 words, it is a function that takes an owned closure that takes no
 arguments.
 
@@ -1751,9 +1765,9 @@ And using this function to iterate over a vector:
 ~~~~
 # use each = vec::each;
 # use println = io::println;
-each([2, 4, 8, 5, 16], |n| {
+each(&[2, 4, 8, 5, 16], |n| {
     if *n % 2 != 0 {
-        println("found odd number!");
+        println(~"found odd number!");
         false
     } else { true }
 });
@@ -1768,9 +1782,9 @@ to the next iteration, write `loop`.
 ~~~~
 # use each = vec::each;
 # use println = io::println;
-for each([2, 4, 8, 5, 16]) |n| {
+for each(&[2, 4, 8, 5, 16]) |n| {
     if *n % 2 != 0 {
-        println("found odd number!");
+        println(~"found odd number!");
         break;
     }
 }
@@ -1813,7 +1827,7 @@ fn map<T, U>(vector: &[T], function: fn(v: &T) -> U) -> ~[U] {
     for vec::each(vector) |element| {
         accumulator.push(function(element));
     }
-    return (move accumulator);
+    return accumulator;
 }
 ~~~~
 
@@ -1953,12 +1967,12 @@ impl int: Printable {
     fn print() { io::println(fmt!("%d", self)) }
 }
 
-impl &str: Printable {
+impl ~str: Printable {
     fn print() { io::println(self) }
 }
 
 # 1.print();
-# ("foo").print();
+# (~"foo").print();
 ~~~~
 
 Methods defined in an implementation of a trait may be called just like
@@ -2106,7 +2120,7 @@ impl @Rectangle: Drawable { fn draw() { ... } }
 
 let c: @Circle = @new_circle();
 let r: @Rectangle = @new_rectangle();
-draw_all([c as @Drawable, r as @Drawable]);
+draw_all(&[c as @Drawable, r as @Drawable]);
 ~~~~
 
 We omit the code for `new_circle` and `new_rectangle`; imagine that
@@ -2148,8 +2162,8 @@ additional modules.
 
 ~~~~
 mod farm {
-    pub fn chicken() -> &str { "cluck cluck" }
-    pub fn cow() -> &str { "mooo" }
+    pub fn chicken() -> ~str { ~"cluck cluck" }
+    pub fn cow() -> ~str { ~"mooo" }
 }
 
 fn main() {
@@ -2346,13 +2360,13 @@ these two files:
 ~~~~
 // world.rs
 #[link(name = "world", vers = "1.0")];
-pub fn explore() -> &str { "world" }
+fn explore() -> ~str { ~"world" }
 ~~~~
 
 ~~~~ {.xfail-test}
 // main.rs
 extern mod world;
-fn main() { io::println("hello " + world::explore()); }
+fn main() { io::println(~"hello " + world::explore()); }
 ~~~~
 
 Now compile and run like this (adjust to your platform if necessary):

trunk/src/cargo/cargo.rs

@@ -705,7 +705,7 @@ fn configure(opts: Options) -> Cargo {
              ~" or package manager to get it to work correctly");
     }
 
-    move c
+    c
 }
 
 fn for_each_package(c: &Cargo, b: fn(s: @Source, p: &Package)) {
@@ -1162,20 +1162,20 @@ fn sync_one_file(c: &Cargo, dir: &Path, src: @Source) -> bool {
     }
     match (src.key, src.keyfp) {
         (Some(_), Some(f)) => {
-            let r = pgp::verify(&c.root, &pkgfile, &sigfile);
+            let r = pgp::verify(&c.root, &pkgfile, &sigfile, f);
 
             if !r {
-                error(fmt!("signature verification failed for source %s with key %s",
-                          name, f));
+                error(fmt!("signature verification failed for source %s",
+                          name));
                 return false;
             }
 
             if has_src_file {
-                let e = pgp::verify(&c.root, &srcfile, &srcsigfile);
+                let e = pgp::verify(&c.root, &srcfile, &srcsigfile, f);
 
                 if !e {
-                    error(fmt!("signature verification failed for source %s with key %s",
-                              name, f));
+                    error(fmt!("signature verification failed for source %s",
+                              name));
                     return false;
                 }
             }
@@ -1273,21 +1273,21 @@ fn sync_one_git(c: &Cargo, dir: &Path, src: @Source) -> bool {
     }
     match (src.key, src.keyfp) {
         (Some(_), Some(f)) => {
-            let r = pgp::verify(&c.root, &pkgfile, &sigfile);
+            let r = pgp::verify(&c.root, &pkgfile, &sigfile, f);
 
             if !r {
-                error(fmt!("signature verification failed for source %s with key %s",
-                          name, f));
+                error(fmt!("signature verification failed for source %s",
+                          name));
                 rollback(name, dir, false);
                 return false;
             }
 
             if has_src_file {
-                let e = pgp::verify(&c.root, &srcfile, &srcsigfile);
+                let e = pgp::verify(&c.root, &srcfile, &srcsigfile, f);
 
                 if !e {
-                    error(fmt!("signature verification failed for source %s with key %s",
-                              name, f));
+                    error(fmt!("signature verification failed for source %s",
+                              name));
                     rollback(name, dir, false);
                     return false;
                 }
@@ -1370,11 +1370,11 @@ fn sync_one_curl(c: &Cargo, dir: &Path, src: @Source) -> bool {
                 return false;
             }
 
-            let r = pgp::verify(&c.root, &pkgfile, &sigfile);
+            let r = pgp::verify(&c.root, &pkgfile, &sigfile, f);
 
             if !r {
-                error(fmt!("signature verification failed for source %s with key %s",
-                          name, f));
+                error(fmt!("signature verification failed for source %s",
+                          name));
                 return false;
             }
 
@@ -1390,11 +1390,11 @@ fn sync_one_curl(c: &Cargo, dir: &Path, src: @Source) -> bool {
                     return false;
                 }
 
-                let e = pgp::verify(&c.root, &srcfile, &srcsigfile);
+                let e = pgp::verify(&c.root, &srcfile, &srcsigfile, f);
 
                 if !e {
                     error(~"signature verification failed for " +
-                          ~"source " + name + ~" with key " + f);
+                          ~"source " + name);
                     return false;
                 }
             }
@@ -1463,7 +1463,8 @@ fn cmd_init(c: &Cargo) {
         return;
     }
 
-    let r = pgp::verify(&c.root, &srcfile, &sigfile);
+    let r = pgp::verify(&c.root, &srcfile, &sigfile,
+                        pgp::signing_key_fp());
     if !r {
         error(fmt!("signature verification failed for '%s'",
                    srcfile.to_str()));
@@ -1614,10 +1615,10 @@ fn dump_sources(c: &Cargo) {
                     _ => ()
                 }
 
-                hash.insert(copy k, json::Object(move chash));
+                hash.insert(copy k, json::Object(chash));
             }
 
-            json::to_writer(writer, &json::Object(move hash))
+            json::to_writer(writer, &json::Object(hash))
         }
         result::Err(e) => {
             error(fmt!("could not dump sources: %s", e));