---

yaml
---
r: 156462
b: refs/heads/snap-stage3
c: e138953
h: refs/heads/master
v: v3

Author: neilpa

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6353465f4df5cc4330f85314a76ff00e0a9a59a0
+refs/heads/snap-stage3: e1389530cf5dca112f5d282acfa7f08a08e114bc
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/crates.mk

@@ -49,11 +49,11 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std green native flate arena term \
-                 serialize sync getopts collections test time rand \
-                 log regex graphviz core rbml rlibc alloc rustrt \
+TARGET_CRATES := libc std green native flate arena glob term semver \
+                 uuid serialize sync getopts collections num test time rand \
+                 url log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
-HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -83,13 +83,18 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
+DEPS_semver := std
+DEPS_uuid := std serialize
 DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
+DEPS_fourcc := rustc syntax std
+DEPS_hexfloat := rustc syntax std
 DEPS_num := std
 DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers
 DEPS_time := std serialize
 DEPS_rand := core
+DEPS_url := std
 DEPS_log := std regex
 DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex

branches/snap-stage3/src/doc/guide.md

@@ -482,7 +482,7 @@ but it will still print "Hello, world!":
    Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world)
 src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)] on by default
 src/main.rs:2     let x: int;
-                      ^
+                             ^
 ```
 
 Rust warns us that we never use the variable binding, but since we never use it,
@@ -1255,9 +1255,8 @@ version, if we had forgotten the `Greater` case, for example, our program would
 have happily compiled. If we forget in the `match`, it will not. Rust helps us
 make sure to cover all of our bases.
 
-`match` is also an expression, which means we can use it on the right
-hand side of a `let` binding or directly where an expression is
-used. We could also implement the previous line like this:
+`match` is also an expression, which means we can use it on the right hand side
+of a `let` binding. We could also implement the previous line like this:
 
 ```{rust}
 fn cmp(a: int, b: int) -> Ordering {
@@ -1270,15 +1269,18 @@ fn main() {
     let x = 5i;
     let y = 10i;
 
-    println!("{}", match cmp(x, y) {
+    let result = match cmp(x, y) {
         Less    => "less",
         Greater => "greater",
         Equal   => "equal",
-    });
+    };
+
+    println!("{}", result);
 }
 ```
 
-Sometimes, it's a nice pattern.
+In this case, it doesn't make a lot of sense, as we are just making a temporary
+string where we don't need to, but sometimes, it's a nice pattern.
 
 # Looping
 
@@ -3095,10 +3097,10 @@ And try to run the test:
 
 ```{notrust,ignore}
 $ cargo test
-   Compiling testing v0.0.1 (file:///home/you/projects/testing)
-/home/you/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
-/home/you/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
-                                                           ^~~~~~~~~~~~~~~~~~~~
+   Compiling testing v0.0.1 (file:///home/youg/projects/testing)
+/home/youg/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
+/home/youg/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
+                                                            ^~~~~~~~~~~~~~~~~~~~
 error: aborting due to previous error
 Build failed, waiting for other jobs to finish...
 Could not compile `testing`.
@@ -3284,11 +3286,11 @@ Let's give it a shot:
 $ cargo test
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
 
-running 2 tests
+running 1 test
 test test::test_times_four ... ok
 test test::test_add_three ... ok
 
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 
 
 running 0 tests
@@ -4363,7 +4365,7 @@ element, `find` returns an `Option` rather than the element itself.
 Another important consumer is `fold`. Here's what it looks like:
 
 ```{rust}
-let sum = range(1i, 4i)
+let sum = range(1i, 100i)
               .fold(0i, |sum, x| sum + x);
 ```
 
@@ -4387,7 +4389,7 @@ in this iterator:
 We called `fold()` with these arguments:
 
 ```{rust}
-# range(1i, 4i)
+# range(1i, 5i)
 .fold(0i, |sum, x| sum + x);
 ```
 

branches/snap-stage3/src/doc/intro.md

@@ -442,10 +442,10 @@ It gives us this error:
 ```
 
 It mentions that "numbers moved into closure environment". Because we referred
-to `numbers` inside of our `proc`, and we create ten `proc`s, we would have ten
-references. Rust detects this and gives us the error: we claim that `numbers`
-has ownership, but our code tries to make ten owners. This may cause a safety
-problem, so Rust disallows it.
+to `numbers` inside of our `proc`, and we create three `proc`s, we would have
+three references. Rust detects this and gives us the error: we claim that
+`numbers` has ownership, but our code tries to make ten owners. This may cause
+a safety problem, so Rust disallows it.
 
 What to do here? Rust has two types that helps us: `Arc<T>` and `Mutex<T>`.
 "Arc" stands for "atomically reference counted." In other words, an Arc will

branches/snap-stage3/src/libcollections/dlist.rs

@@ -475,6 +475,12 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
+    /// Deprecated: use `iter_mut`.
+    #[deprecated = "use iter_mut"]
+    pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
+        self.iter_mut()
+    }
+
     /// Provides a forward iterator with mutable references.
     #[inline]
     pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
@@ -490,6 +496,12 @@ impl<T> DList<T> {
         }
     }
 
+    /// Deprecated: use `into_iter`.
+    #[deprecated = "use into_iter"]
+    pub fn move_iter(self) -> MoveItems<T> {
+        self.into_iter()
+    }
+
     /// Consumes the list into an iterator yielding elements by value.
     #[inline]
     pub fn into_iter(self) -> MoveItems<T> {
@@ -858,8 +870,7 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.append(list_from(u.as_slice()));
         check_links(&m);
-        let mut sum = v;
-        sum.push_all(u.as_slice());
+        let sum = v.append(u.as_slice());
         assert_eq!(sum.len(), m.len());
         for elt in sum.into_iter() {
             assert_eq!(m.pop_front(), Some(elt))

branches/snap-stage3/src/libcollections/lib.rs

@@ -502,6 +502,40 @@ pub trait Deque<T> : MutableSeq<T> {
     /// ```
     fn push_front(&mut self, elt: T);
 
+    /// Inserts an element last in the sequence.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{DList, Deque};
+    ///
+    /// let mut d = DList::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    /// assert_eq!(d.front(), Some(&1i));
+    /// ```
+    #[deprecated = "use the `push` method"]
+    fn push_back(&mut self, elt: T) { self.push(elt) }
+
+    /// Removes the last element and returns it, or `None` if the sequence is
+    /// empty.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{RingBuf, Deque};
+    ///
+    /// let mut d = RingBuf::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    ///
+    /// assert_eq!(d.pop_back(), Some(2i));
+    /// assert_eq!(d.pop_back(), Some(1i));
+    /// assert_eq!(d.pop_back(), None);
+    /// ```
+    #[deprecated = "use the `pop` method"]
+    fn pop_back(&mut self) -> Option<T> { self.pop() }
+
     /// Removes the first element and returns it, or `None` if the sequence is
     /// empty.
     ///

branches/snap-stage3/src/libcollections/priority_queue.rs

@@ -269,6 +269,9 @@ impl<T: Ord> PriorityQueue<T> {
         if self.is_empty() { None } else { Some(&self.data[0]) }
     }
 
+    #[deprecated="renamed to `top`"]
+    pub fn maybe_top<'a>(&'a self) -> Option<&'a T> { self.top() }
+
     /// Returns the number of elements the queue can hold without reallocating.
     ///
     /// # Example
@@ -338,6 +341,9 @@ impl<T: Ord> PriorityQueue<T> {
         }
     }
 
+    #[deprecated="renamed to `pop`"]
+    pub fn maybe_pop(&mut self) -> Option<T> { self.pop() }
+
     /// Pushes an item onto the queue.
     ///
     /// # Example
@@ -411,6 +417,14 @@ impl<T: Ord> PriorityQueue<T> {
         }
     }
 
+    #[allow(dead_code)]
+    #[deprecated="renamed to `into_vec`"]
+    fn to_vec(self) -> Vec<T> { self.into_vec() }
+
+    #[allow(dead_code)]
+    #[deprecated="renamed to `into_sorted_vec`"]
+    fn to_sorted_vec(self) -> Vec<T> { self.into_sorted_vec() }
+
     /// Consumes the `PriorityQueue` and returns the underlying vector
     /// in arbitrary order.
     ///