---

yaml
---
r: 156639
b: refs/heads/try
c: 6ef8392
h: refs/heads/master
i:
  156637: 2b1c3b1
  156635: 0694259
  156631: 2bb6bb1
  156623: 4c2d406
  156607: 5bdbaf3
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a34b8dec697014f15e725215e17ea8d956c0ab1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
-refs/heads/try: f358407dcfe4cb50a65110aad31bf88c87e72d39
+refs/heads/try: 6ef8392b3fd5f81165f1b4637a94c7c226420070
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

branches/try/mk/crates.mk

@@ -49,11 +49,11 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-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 \
+TARGET_CRATES := libc std green native flate arena term \
+                 serialize sync getopts collections test time rand \
+                 log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
-HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -83,18 +83,13 @@ 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/try/src/doc/guide.md

@@ -3095,10 +3095,10 @@ And try to run the test:
 
 ```{notrust,ignore}
 $ cargo test
-   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);
-                                                            ^~~~~~~~~~~~~~~~~~~~
+   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);
+                                                           ^~~~~~~~~~~~~~~~~~~~
 error: aborting due to previous error
 Build failed, waiting for other jobs to finish...
 Could not compile `testing`.
@@ -3284,11 +3284,11 @@ Let's give it a shot:
 $ cargo test
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
 
-running 1 test
+running 2 tests
 test test::test_times_four ... ok
 test test::test_add_three ... ok
 
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
 
 
 running 0 tests
@@ -4363,7 +4363,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, 100i)
+let sum = range(1i, 4i)
               .fold(0i, |sum, x| sum + x);
 ```
 
@@ -4387,7 +4387,7 @@ in this iterator:
 We called `fold()` with these arguments:
 
 ```{rust}
-# range(1i, 5i)
+# range(1i, 4i)
 .fold(0i, |sum, x| sum + x);
 ```
 

branches/try/src/doc/intro.md

@@ -442,21 +442,21 @@ 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 three 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
 keep track of the number of references to something, and not free the
 associated resource until the count is zero. The 'atomic' portion refers to an
 Arc's usage of concurrency primitives to atomically update the count, making it
-safe across threads. If we use an Arc, we can have our ten references. But, an
-Arc does not allow mutable borrows of the data it holds, and we want to modify
-what we're sharing. In this case, we can use a `Mutex<T>` inside of our Arc. A
-Mutex will synchronize our accesses, so that we can ensure that our mutation
-doesn't cause a data race.
+safe across threads. If we use an Arc, we can have our three references. But,
+an Arc does not allow mutable borrows of the data it holds, and we want to
+modify what we're sharing. In this case, we can use a `Mutex<T>` inside of our
+Arc. A Mutex will synchronize our accesses, so that we can ensure that our
+mutation doesn't cause a data race.
 
 Here's what using an Arc with a Mutex looks like:
 

branches/try/src/libcollections/dlist.rs

@@ -475,12 +475,6 @@ 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> {
@@ -496,12 +490,6 @@ 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> {
@@ -870,7 +858,8 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.append(list_from(u.as_slice()));
         check_links(&m);
-        let sum = v.append(u.as_slice());
+        let mut sum = v;
+        sum.push_all(u.as_slice());
         assert_eq!(sum.len(), m.len());
         for elt in sum.into_iter() {
             assert_eq!(m.pop_front(), Some(elt))

branches/try/src/libcollections/lib.rs

@@ -502,40 +502,6 @@ 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/try/src/libcollections/priority_queue.rs

@@ -269,9 +269,6 @@ 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
@@ -341,9 +338,6 @@ 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
@@ -417,14 +411,6 @@ 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.
     ///