---

yaml
---
r: 115435
b: refs/heads/try
c: b0977b1
h: refs/heads/master
i:
  115433: c364645
  115431: f8c8a9b
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: bee4e6adac17f87b1cdc26ab69f8c0f5d82575a3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
-refs/heads/try: 825f6ace1d8692af23f4a2842c87cb2dcc864fad
+refs/heads/try: b0977b1e0f7ba53b6301e2d5f7b26dd2d9c72fbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/LICENSE-MIT

@@ -1,5 +1,4 @@
-Copyright (c) 2006-2009 Graydon Hoare
-Copyright (c) 2009-2014 Mozilla Foundation
+Copyright (c) 2014 The Rust Project Developers
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

branches/try/src/doc/guide-pointers.md

@@ -186,7 +186,7 @@ enum List<T> {
     Nil,
     Cons(T, ~List<T>),
 }
-    
+
 fn main() {
     let list: List<int> = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
     println!("{:?}", list);
@@ -251,7 +251,7 @@ struct.
 
 > **Note**: the `@` form of managed pointers is deprecated and behind a
 > feature gate (it requires a `#![feature(managed_pointers)]` attribute on
-> the crate root; remember the semicolon!). There are replacements, currently 
+> the crate root). There are replacements, currently
 > there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
 > counting and garbage collection respectively.
 
@@ -266,7 +266,7 @@ struct Point {
     x: int,
     y: int,
 }
-    
+
 fn main() {
     let a = ~Point { x: 10, y: 20 };
     let b = a;
@@ -297,7 +297,7 @@ struct Point {
     x: int,
     y: int,
 }
-    
+
 fn main() {
     let a = @Point { x: 10, y: 20 };
     let b = a;
@@ -361,7 +361,7 @@ So how is this hard? Well, because we're ignoring ownership, the compiler needs
 to take great care to make sure that everything is safe. Despite their complete
 safety, a reference's representation at runtime is the same as that of
 an ordinary pointer in a C program. They introduce zero overhead. The compiler
-does all safety checks at compile time. 
+does all safety checks at compile time.
 
 This theory is called 'region pointers,' and involve a concept called
 'lifetimes'. Here's the simple explanation: would you expect this code to
@@ -477,7 +477,7 @@ fn main() {
 You may think that this gives us terrible performance: return a value and then
 immediately box it up?!?! Isn't that the worst of both worlds? Rust is smarter
 than that. There is no copy in this code. `main` allocates enough room for the
-`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes 
+`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
 the value straight into that pointer. This writes the return value directly into
 the allocated box.
 

branches/try/src/doc/guide-tasks.md

@@ -101,6 +101,8 @@ 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
+// This uses the proc() keyword to assign to spawn a function with no name
+// That function will call println!(...) as requested
 spawn(proc() println!("I am also running in a different task!") );
 ~~~~
 

branches/try/src/doc/tutorial.md

@@ -1720,38 +1720,103 @@ environment (sometimes referred to as "capturing" variables in their
 environment). For example, you couldn't write the following:
 
 ~~~~ {.ignore}
-let foo = 10;
+let x = 3;
 
-fn bar() -> int {
-   return foo; // `bar` cannot refer to `foo`
-}
+// `fun` cannot refer to `x`
+fn fun() -> () { println!("{}", x); }
 ~~~~
 
-Rust also supports _closures_, functions that can access variables in
-the enclosing scope.
+A _closure_ does support accessing the enclosing scope; below we will create
+2 _closures_ (nameless functions). Compare how `||` replaces `()` and how
+they try to access `x`:
 
-~~~~
-fn call_closure_with_ten(b: |int|) { b(10); }
+~~~~ {.ignore}
+let x = 3;
 
-let captured_var = 20;
-let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
+// `fun` is an invalid definition
+fn  fun       () -> () { println!("{}", x) }  // cannot capture from enclosing scope
+let closure = || -> () { println!("{}", x) }; // can capture from enclosing scope
 
-call_closure_with_ten(closure);
+// `fun_arg` is an invalid definition
+fn  fun_arg       (arg: int) -> () { println!("{}", arg + x) }  // cannot capture
+let closure_arg = |arg: int| -> () { println!("{}", arg + x) }; // can capture
+//                      ^
+// Requires a type because the implementation needs to know which `+` to use.
+// In the future, the implementation may not need the help.
+
+fun();          // Still won't work
+closure();      // Prints: 3
+
+fun_arg(7);     // Still won't work
+closure_arg(7); // Prints: 10
 ~~~~
 
 Closures begin with the argument list between vertical bars and are followed by
 a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
 considered a single expression: it evaluates to the result of the last
 expression it contains if that expression is not followed by a semicolon,
-otherwise the block evaluates to `()`.
+otherwise the block evaluates to `()`, the unit value.
+
+In general, return types and all argument types must be specified
+explicitly for function definitions.  (As previously mentioned in the
+[Functions section](#functions), omitting the return type from a
+function declaration is synonymous with an explicit declaration of
+return type unit, `()`.)
+
+~~~~ {.ignore}
+fn  fun   (x: int)         { println!("{}", x) } // this is same as saying `-> ()`
+fn  square(x: int) -> uint { (x * x) as uint }   // other return types are explicit
+
+// Error: mismatched types: expected `()` but found `uint`
+fn  badfun(x: int)         { (x * x) as uint }
+~~~~
+
+On the other hand, the compiler can usually infer both the argument
+and return types for a closure expression; therefore they are often
+omitted, since both a human reader and the compiler can deduce the
+types from the immediate context.  This is in contrast to function
+declarations, which require types to be specified and are not subject
+to type inference. Compare:
 
-The types of the arguments are generally omitted, as is the return type,
-because the compiler can almost always infer them. In the rare case where the
-compiler needs assistance, though, the arguments and return types may be
-annotated.
+~~~~ {.ignore}
+// `fun` as a function declaration cannot infer the type of `x`, so it must be provided
+fn  fun       (x: int) { println!("{}", x) }
+let closure = |x     | { println!("{}", x) }; // infers `x: int`, return type `()`
+
+// For closures, omitting a return type is *not* synonymous with `-> ()`
+let add_3   = |y     | { 3i + y }; // infers `y: int`, return type `int`.
+
+fun(10);            // Prints 10
+closure(20);        // Prints 20
+closure(add_3(30)); // Prints 33
 
+fun("String"); // Error: mismatched types
+
+// Error: mismatched types
+// inference already assigned `closure` the type `|int| -> ()`
+closure("String");
 ~~~~
-let square = |x: int| -> uint { (x * x) as uint };
+
+In cases where the compiler needs assistance, the arguments and return
+types may be annotated on closures, using the same notation as shown
+earlier.  In the example below, since different types provide an
+implementation for the operator `*`, the argument type for the `x`
+parameter must be explicitly provided.
+
+~~~~{.ignore}
+// Error: the type of `x` must be known to be used with `x * x`
+let square = |x     | -> uint { (x * x) as uint };
+~~~~
+
+In the corrected version, the argument type is explicitly annotated,
+while the return type can still be inferred.
+
+~~~~
+let square_explicit = |x: int| -> uint { (x * x) as uint };
+let square_infer    = |x: int|         { (x * x) as uint };
+
+println!("{}", square_explicit(20));  // 400
+println!("{}", square_infer(-20));    // 400
 ~~~~
 
 There are several forms of closure, each with its own role. The most

branches/try/src/etc/emacs/README.md

@@ -12,11 +12,12 @@ To install manually, check out this repository and add this to your
 
 ```lisp
 (add-to-list 'load-path "/path/to/rust-mode/")
-(require 'rust-mode)
+(autoload 'rust-mode "rust-mode" nil t)
+(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
 ```
 
-`rust-mode` will automatically be associated with `.rs` files. To enable it
-explicitly, do <kbd>M-x rust-mode</kbd>.
+This associates `rust-mode` with `.rs` files. To enable it explicitly, do
+<kbd>M-x rust-mode</kbd>.
 
 ### `package.el` installation via Marmalade or MELPA
 

branches/try/src/etc/emacs/rust-mode.el

@@ -169,7 +169,7 @@
 ;; Font-locking definitions and helpers
 (defconst rust-mode-keywords
   '("as"
-    "break"
+    "box" "break"
     "continue" "crate"
     "do"
     "else" "enum" "extern"

branches/try/src/libarena/lib.rs

@@ -517,7 +517,7 @@ mod tests {
     #[bench]
     pub fn bench_copy_nonarena(b: &mut Bencher) {
         b.iter(|| {
-            ~Point {
+            box Point {
                 x: 1,
                 y: 2,
                 z: 3,
@@ -569,7 +569,7 @@ mod tests {
     #[bench]
     pub fn bench_noncopy_nonarena(b: &mut Bencher) {
         b.iter(|| {
-            ~Noncopy {
+            box Noncopy {
                 string: "hello world".to_owned(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             }

branches/try/src/libcollections/btree.rs

@@ -377,8 +377,8 @@ impl<K: Clone + TotalOrd, V: Clone> Leaf<K, V> {
                                                               == Less);
             let branch_return = Node::new_branch(vec!(BranchElt::new(midpoint.key.clone(),
                                                                   midpoint.value.clone(),
-                                                             ~Node::new_leaf(left_leaf))),
-                                            ~Node::new_leaf(right_leaf));
+                                                             box Node::new_leaf(left_leaf))),
+                                            box Node::new_leaf(right_leaf));
             return (branch_return, true);
         }
         (Node::new_leaf(self.elts.clone()), true)
@@ -540,10 +540,10 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                     //so we can return false.
                     LeafNode(..) => {
                         if index.unwrap() == self.elts.len() {
-                            self.rightmost_child = ~new_branch.clone();
+                            self.rightmost_child = box new_branch.clone();
                         }
                         else {
-                            self.elts.get_mut(index.unwrap()).left = ~new_branch.clone();
+                            self.elts.get_mut(index.unwrap()).left = box new_branch.clone();
                         }
                         return (Node::new_branch(self.clone().elts,
                                                  self.clone().rightmost_child),
@@ -561,10 +561,10 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                 //and return it, saying we have inserted a new element.
                 LeafNode(..) => {
                     if index.unwrap() == self.elts.len() {
-                        self.rightmost_child = ~new_branch;
+                        self.rightmost_child = box new_branch;
                     }
                     else {
-                        self.elts.get_mut(index.unwrap()).left = ~new_branch;
+                        self.elts.get_mut(index.unwrap()).left = box new_branch;
                     }
                     return (Node::new_branch(self.clone().elts,
                                              self.clone().rightmost_child),
@@ -604,9 +604,9 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
                 new_branch = Node::new_branch(
                     vec!(BranchElt::new(midpoint.clone().key,
                                      midpoint.clone().value,
-                                     ~Node::new_branch(new_left,
+                                     box Node::new_branch(new_left,
                                                        midpoint.clone().left))),
-                    ~Node::new_branch(new_right, self.clone().rightmost_child));
+                    box Node::new_branch(new_right, self.clone().rightmost_child));
                 return (new_branch, true);
             }
         }

branches/try/src/libcollections/dlist.rs

@@ -238,7 +238,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn push_front(&mut self, elt: T) {
-        self.push_front_node(~Node::new(elt))
+        self.push_front_node(box Node::new(elt))
     }
 
     /// Remove the first element and return it, or None if the list is empty
@@ -252,7 +252,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn push_back(&mut self, elt: T) {
-        self.push_back_node(~Node::new(elt))
+        self.push_back_node(box Node::new(elt))
     }
 
     /// Remove the last element and return it, or None if the list is empty
@@ -555,7 +555,7 @@ impl<'a, A> MutItems<'a, A> {
 impl<'a, A> ListInsertion<A> for MutItems<'a, A> {
     #[inline]
     fn insert_next(&mut self, elt: A) {
-        self.insert_next_node(~Node::new(elt))
+        self.insert_next_node(box Node::new(elt))
     }
 
     #[inline]
@@ -675,19 +675,19 @@ mod tests {
         assert_eq!(m.pop_front(), None);
         assert_eq!(m.pop_back(), None);
         assert_eq!(m.pop_front(), None);
-        m.push_front(~1);
+        m.push_front(box 1);
         assert_eq!(m.pop_front(), Some(~1));
-        m.push_back(~2);
-        m.push_back(~3);
+        m.push_back(box 2);
+        m.push_back(box 3);
         assert_eq!(m.len(), 2);
         assert_eq!(m.pop_front(), Some(~2));
         assert_eq!(m.pop_front(), Some(~3));
         assert_eq!(m.len(), 0);
         assert_eq!(m.pop_front(), None);
-        m.push_back(~1);
-        m.push_back(~3);
-        m.push_back(~5);
-        m.push_back(~7);
+        m.push_back(box 1);
+        m.push_back(box 3);
+        m.push_back(box 5);
+        m.push_back(box 7);
         assert_eq!(m.pop_front(), Some(~1));
 
         let mut n = DList::new();

branches/try/src/libcollections/lru_cache.rs

@@ -93,7 +93,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ cast::transmute(~mem::uninit::<LruEntry<K, V>>()) },
+            head: unsafe{ cast::transmute(box mem::uninit::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;
@@ -111,7 +111,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
                 (node_ptr, None)
             }
             None => {
-                let mut node = ~LruEntry::new(k, v);
+                let mut node = box LruEntry::new(k, v);
                 let node_ptr: *mut LruEntry<K, V> = &mut *node;
                 (node_ptr, Some(node))
             }

branches/try/src/libcollections/priority_queue.rs

@@ -273,19 +273,19 @@ mod tests {
         let mut heap = PriorityQueue::from_vec(vec!(~2, ~4, ~9));
         assert_eq!(heap.len(), 3);
         assert!(*heap.top() == ~9);
-        heap.push(~11);
+        heap.push(box 11);
         assert_eq!(heap.len(), 4);
         assert!(*heap.top() == ~11);
-        heap.push(~5);
+        heap.push(box 5);
         assert_eq!(heap.len(), 5);
         assert!(*heap.top() == ~11);
-        heap.push(~27);
+        heap.push(box 27);
         assert_eq!(heap.len(), 6);
         assert!(*heap.top() == ~27);
-        heap.push(~3);
+        heap.push(box 3);
         assert_eq!(heap.len(), 7);
         assert!(*heap.top() == ~27);
-        heap.push(~103);
+        heap.push(box 103);
         assert_eq!(heap.len(), 8);
         assert!(*heap.top() == ~103);
     }