---

yaml
---
r: 277231
b: refs/heads/try
c: f089cf9
h: refs/heads/master
i:
  277229: 2bf306c
  277227: 1b72986
  277223: dd61a6a
  277215: 3fee18b

Author: Manishearth

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 31374d8030a30803d018c7a70b70e59030713adb
+refs/heads/try: f089cf9b2ff2602edd989480b7cd9d4b8b820f84
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/CONTRIBUTING.md

@@ -307,7 +307,7 @@ are:
 [gsearchdocs]: https://www.google.com/search?q=site:doc.rust-lang.org+your+query+here
 [rif]: http://internals.rust-lang.org
 [rr]: https://doc.rust-lang.org/book/README.html
-[tlgba]: http://tomlee.co/2014/04/a-more-detailed-tour-of-the-rust-compiler/
+[tlgba]: http://tomlee.co/2014/04/03/a-more-detailed-tour-of-the-rust-compiler/
 [ro]: http://www.rustaceans.org/
 [rctd]: ./COMPILER_TESTS.md
 [cheatsheet]: http://buildbot.rust-lang.org/homu/

branches/try/RELEASES.md

@@ -140,9 +140,9 @@ Cargo
 Performance
 -----------
 
-* [The time complexity of comparing variables for equivalence during type 
-  unification is reduced from _O_(_n_!) to _O_(_n_)][1.9tu]. This leads
-  to major compilation time improvement in some scenarios.
+* [During type unification, the complexity of comparing variables for
+  equivalance was reduced from `O(n!)` to `O(n)`][1.9tu]. This leads
+  to major compile-time improvements in some scenarios.
 * [`ToString` is specialized for `str`, giving it the same performance
   as `to_owned`][1.9ts].
 * [Spawning processes with `Command::output` no longer creates extra

branches/try/src/doc/book/casting-between-types.md

@@ -165,15 +165,10 @@ Rust lets us:
 ```rust
 use std::mem;
 
-fn main() {
-    unsafe {
-        let a = [0u8, 1u8, 0u8, 0u8];
-        let b = mem::transmute::<[u8; 4], u32>(a);
-        println!("{}", b); // 256
-        // or, more concisely:
-        let c: u32 = mem::transmute(a);
-        println!("{}", c); // 256
-    }
+unsafe {
+    let a = [0u8, 0u8, 0u8, 0u8];
+
+    let b = mem::transmute::<[u8; 4], u32>(a);
 }
 ```
 

branches/try/src/doc/book/mutability.md

@@ -24,16 +24,18 @@ changed from one `i32` to another.
 
 [vb]: variable-bindings.html
 
-You can also create a [reference][ref] to it, using `&x`, but if you want to use the reference to change it, you will need a mutable reference:
+If you want to change what the binding points to, you’ll need a [mutable reference][mr]:
 
 ```rust
 let mut x = 5;
 let y = &mut x;
 ```
 
-[ref]: references-and-borrowing.html
+[mr]: references-and-borrowing.html
 
-`y` is an immutable binding to a mutable reference, which means that you can’t bind 'y' to something else (`y = &mut z`), but `y` can be used to bind `x` to something else (`*y = 5`). A subtle distinction.
+`y` is an immutable binding to a mutable reference, which means that you can’t
+bind `y` to something else (`y = &mut z`), but you can mutate the thing that’s
+bound to `y` (`*y = 5`). A subtle distinction.
 
 Of course, if you need both:
 

branches/try/src/doc/book/ownership.md

@@ -173,11 +173,11 @@ For example if we truncated the vector to just two elements through `v2`:
 v2.truncate(2);
 ```
 
-and `v` were still accessible we'd end up with an invalid vector since `v`
+and `v1` were still accessible we'd end up with an invalid vector since `v1`
 would not know that the heap data has been truncated. Now, the part of the
-vector `v` on the stack does not agree with the corresponding part on the
-heap. `v` still thinks there are three elements in the vector and will
-happily let us access the non existent element `v[2]` but as you might
+vector `v1` on the stack does not agree with the corresponding part on the
+heap. `v1` still thinks there are three elements in the vector and will
+happily let us access the non existent element `v1[2]` but as you might
 already know this is a recipe for disaster. Especially because it might lead
 to a segmentation fault or worse allow an unauthorized user to read from
 memory to which they don't have access.

branches/try/src/doc/book/primitive-types.md

@@ -97,10 +97,9 @@ and `i64` is a signed, 64-bit integer.
 
 ## Variable-size types
 
-Rust also provides types whose particular size depends on the underlying machine
-architecture. Their range is sufficient to express the size of any collection, so
-these types have ‘size’ as the category. They come in signed and unsigned varieties
-which account for two types: `isize` and `usize`.
+Rust also provides types whose size depends on the size of a pointer of the
+underlying machine. These types have ‘size’ as the category, and come in signed
+and unsigned varieties. This makes for two types: `isize` and `usize`.
 
 ## Floating-point types
 

branches/try/src/libcollections/binary_heap.rs

@@ -153,15 +153,12 @@
 
 use core::iter::FromIterator;
 use core::mem::swap;
-use core::mem::size_of;
 use core::ptr;
 use core::fmt;
 
 use slice;
 use vec::{self, Vec};
 
-use super::SpecExtend;
-
 /// A priority queue implemented with a binary heap.
 ///
 /// This will be a max-heap.
@@ -741,71 +738,6 @@ impl<T: Ord> BinaryHeap<T> {
     pub fn clear(&mut self) {
         self.drain();
     }
-
-    fn rebuild(&mut self) {
-        let mut n = self.len() / 2;
-        while n > 0 {
-            n -= 1;
-            self.sift_down(n);
-        }
-    }
-
-    /// Moves all the elements of `other` into `self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(binary_heap_append)]
-    ///
-    /// use std::collections::BinaryHeap;
-    ///
-    /// let v = vec![-10, 1, 2, 3, 3];
-    /// let mut a = BinaryHeap::from(v);
-    ///
-    /// let v = vec![-20, 5, 43];
-    /// let mut b = BinaryHeap::from(v);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]);
-    /// assert!(b.is_empty());
-    /// ```
-    #[unstable(feature = "binary_heap_append",
-           reason = "needs to be audited",
-           issue = "32526")]
-    pub fn append(&mut self, other: &mut Self) {
-        if self.len() < other.len() {
-            swap(self, other);
-        }
-
-        if other.is_empty() {
-            return;
-        }
-
-        #[inline(always)]
-        fn log2_fast(x: usize) -> usize {
-            8 * size_of::<usize>() - (x.leading_zeros() as usize) - 1
-        }
-
-        // `rebuild` takes O(len1 + len2) operations
-        // and about 2 * (len1 + len2) comparisons in the worst case
-        // while `extend` takes O(len2 * log_2(len1)) operations
-        // and about 1 * len2 * log_2(len1) comparisons in the worst case,
-        // assuming len1 >= len2.
-        #[inline]
-        fn better_to_rebuild(len1: usize, len2: usize) -> bool {
-            2 * (len1 + len2) < len2 * log2_fast(len1)
-        }
-
-        if better_to_rebuild(self.len(), other.len()) {
-            self.data.append(&mut other.data);
-            self.rebuild();
-        } else {
-            self.extend(other.drain());
-        }
-    }
 }
 
 /// Hole represents a hole in a slice i.e. an index without valid value
@@ -919,7 +851,6 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 /// An iterator that moves out of a `BinaryHeap`.
 #[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Clone)]
 pub struct IntoIter<T> {
     iter: vec::IntoIter<T>,
 }
@@ -986,7 +917,11 @@ impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
 impl<T: Ord> From<Vec<T>> for BinaryHeap<T> {
     fn from(vec: Vec<T>) -> BinaryHeap<T> {
         let mut heap = BinaryHeap { data: vec };
-        heap.rebuild();
+        let mut n = heap.len() / 2;
+        while n > 0 {
+            n -= 1;
+            heap.sift_down(n);
+        }
         heap
     }
 }
@@ -1045,26 +980,7 @@ impl<'a, T> IntoIterator for &'a BinaryHeap<T> where T: Ord {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Extend<T> for BinaryHeap<T> {
-    #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        <Self as SpecExtend<I>>::spec_extend(self, iter);
-    }
-}
-
-impl<T: Ord, I: IntoIterator<Item = T>> SpecExtend<I> for BinaryHeap<T> {
-    default fn spec_extend(&mut self, iter: I) {
-        self.extend_desugared(iter.into_iter());
-    }
-}
-
-impl<T: Ord> SpecExtend<BinaryHeap<T>> for BinaryHeap<T> {
-    fn spec_extend(&mut self, ref mut other: BinaryHeap<T>) {
-        self.append(other);
-    }
-}
-
-impl<T: Ord> BinaryHeap<T> {
-    fn extend_desugared<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         let iterator = iter.into_iter();
         let (lower, _) = iterator.size_hint();