---

yaml
---
r: 204989
b: refs/heads/tmp
c: 770f0e9
h: refs/heads/master
i:
  204987: c44a394
v: v3

Author: Johann Hofmann

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: f0213d8ffb128a16f94af7ee985dc61484596163
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: f2c2736cd8ac05315bd32e82e7433a168631bb36
+refs/heads/tmp: 770f0e95a189e84491845ab1378eb3bc3c896f62
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f0ac7e04e647381e2bb87de1f3d0b108acb24d06
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/doc/reference.md

@@ -653,10 +653,9 @@ There are several kinds of item:
 * [`use` declarations](#use-declarations)
 * [modules](#modules)
 * [functions](#functions)
-* [type aliases](#type-aliases)
+* [type definitions](#type-definitions)
 * [structures](#structures)
 * [enumerations](#enumerations)
-* [constant items](#constant-items)
 * [static items](#static-items)
 * [traits](#traits)
 * [implementations](#implementations)
@@ -673,16 +672,16 @@ which sub-item declarations may appear.
 
 ### Type Parameters
 
-All items except modules, constants and statics may be *parameterized* by type.
-Type parameters are given as a comma-separated list of identifiers enclosed in
-angle brackets (`<...>`), after the name of the item and before its definition.
-The type parameters of an item are considered "part of the name", not part of
-the type of the item. A referencing [path](#paths) must (in principle) provide
-type arguments as a list of comma-separated types enclosed within angle
-brackets, in order to refer to the type-parameterized item. In practice, the
-type-inference system can usually infer such argument types from context. There
-are no general type-parametric types, only type-parametric items. That is, Rust
-has no notion of type abstraction: there are no first-class "forall" types.
+All items except modules may be *parameterized* by type. Type parameters are
+given as a comma-separated list of identifiers enclosed in angle brackets
+(`<...>`), after the name of the item and before its definition. The type
+parameters of an item are considered "part of the name", not part of the type
+of the item. A referencing [path](#paths) must (in principle) provide type
+arguments as a list of comma-separated types enclosed within angle brackets, in
+order to refer to the type-parameterized item. In practice, the type-inference
+system can usually infer such argument types from context. There are no
+general type-parametric types, only type-parametric items. That is, Rust has
+no notion of type abstraction: there are no first-class "forall" types.
 
 ### Modules
 
@@ -744,7 +743,7 @@ mod thread {
 }
 ```
 
-#### Extern crate declarations
+##### Extern crate declarations
 
 An _`extern crate` declaration_ specifies a dependency on an external crate.
 The external crate is then bound into the declaring scope as the `ident`
@@ -768,7 +767,7 @@ extern crate std; // equivalent to: extern crate std as std;
 extern crate std as ruststd; // linking to 'std' under another name
 ```
 
-#### Use declarations
+##### Use declarations
 
 A _use declaration_ creates one or more local name bindings synonymous with
 some other [path](#paths). Usually a `use` declaration is used to shorten the
@@ -843,7 +842,7 @@ module declarations should be at the crate root if direct usage of the declared
 modules within `use` items is desired. It is also possible to use `self` and
 `super` at the beginning of a `use` item to refer to the current and direct
 parent modules respectively. All rules regarding accessing declared modules in
-`use` declarations apply to both module declarations and `extern crate`
+`use` declarations applies to both module declarations and `extern crate`
 declarations.
 
 An example of what will and will not work for `use` items:
@@ -2565,19 +2564,12 @@ array is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can
 be assigned to.
 
 Indices are zero-based, and may be of any integral type. Vector access is
-bounds-checked at compile-time for constant arrays being accessed with a constant index value.
-Otherwise a check will be performed at run-time that will put the thread in a _panicked state_ if it fails.
+bounds-checked at run-time. When the check fails, it will put the thread in a
+_panicked state_.
 
 ```{should-fail}
 ([1, 2, 3, 4])[0];
-
-let x = (["a", "b"])[10]; // compiler error: const index-expr is out of bounds
-
-let n = 10;
-let y = (["a", "b"])[n]; // panics
-
-let arr = ["a", "b"];
-arr[10]; // panics
+(["a", "b"])[10]; // panics
 ```
 
 ### Range expressions
@@ -3072,6 +3064,17 @@ of a condition expression it expects a refutable let statement. If the value of
 expression on the right hand side of the let statement matches the pattern, the corresponding
 block will execute, otherwise flow proceeds to the first `else` block that follows.
 
+```
+let dish = ("Ham", "Eggs");
+if let ("Bacon", b) = dish { // will not execute because let is refuted
+  println!("Bacon is served with {}", b);
+}
+
+if let ("Ham", b) = dish { // will execute
+  println!("Ham is served with {}", b);
+}
+```
+
 ### While let loops
 
 A `while let` loop is semantically identical to a `while` loop but in place of a

branches/tmp/src/doc/trpl/guessing-game.md

@@ -273,7 +273,7 @@ information’. Why throw it away? Well, for a basic program, we just want to
 print a generic error, as basically any issue means we can’t continue. The
 [`ok()` method][ok] returns a value which has another method defined on it:
 `expect()`. The [`expect()` method][expect] takes a value it’s called on, and
-if it isn’t a successful one, [`panic!`][panic]s with a message you
+if it isn’t a successful one, [`panic!`][panic]s with a message you passed you
 passed it. A `panic!` like this will cause our program to crash, displaying
 the message.
 
@@ -713,7 +713,7 @@ variety of numbers, we need to give Rust a hint as to the exact type of number
 we want. Hence, `let guess: u32`. The colon (`:`) after `guess` tells Rust
 we’re going to annotate its type. `u32` is an unsigned, thirty-two bit
 integer. Rust has [a number of built-in number types][number], but we’ve
-chosen `u32`. It’s a good default choice for a small positive number.
+chosen `u32`. It’s a good default choice for a small positive numer.
 
 [parse]: ../std/primitive.str.html#method.parse
 [number]: primitive-types.html#numeric-types
@@ -922,7 +922,7 @@ failure. Each contains more information: the successful parsed integer, or an
 error type. In this case, we `match` on `Ok(num)`, which sets the inner value
 of the `Ok` to the name `num`, and then we just return it on the right-hand
 side. In the `Err` case, we don’t care what kind of error it is, so we just
-use `_` instead of a name. This ignores the error, and `continue` causes us
+use `_` intead of a name. This ignores the error, and `continue` causes us
 to go to the next iteration of the `loop`.
 
 Now we should be good! Let’s try:

branches/tmp/src/doc/trpl/match.md

@@ -50,7 +50,7 @@ side of a `let` binding or directly where an expression is used:
 ```rust
 let x = 5;
 
-let number = match x {
+let numer = match x {
     1 => "one",
     2 => "two",
     3 => "three",

branches/tmp/src/doc/trpl/mutability.md

@@ -78,8 +78,8 @@ When we call `clone()`, the `Arc<T>` needs to update the reference count. Yet
 we’ve not used any `mut`s here, `x` is an immutable binding, and we didn’t take
 `&mut 5` or anything. So what gives?
 
-To understand this, we have to go back to the core of Rust’s guiding
-philosophy, memory safety, and the mechanism by which Rust guarantees it, the
+To this, we have to go back to the core of Rust’s guiding philosophy, memory
+safety, and the mechanism by which Rust guarantees it, the
 [ownership][ownership] system, and more specifically, [borrowing][borrowing]:
 
 > You may have one or the other of these two kinds of borrows, but not both at
@@ -169,7 +169,7 @@ struct Point {
     y: Cell<i32>,
 }
 
-let point = Point { x: 5, y: Cell::new(6) };
+let mut point = Point { x: 5, y: Cell::new(6) };
 
 point.y.set(7);
 

branches/tmp/src/doc/trpl/ownership.md

@@ -174,7 +174,7 @@ fn foo(v: Vec<i32>) -> Vec<i32> {
 }
 ```
 
-This would get very tedious. It gets worse the more things we want to take ownership of:
+This would get very tedius. It gets worse the more things we want to take ownership of:
 
 ```rust
 fn foo(v1: Vec<i32>, v2: Vec<i32>) -> (Vec<i32>, Vec<i32>, i32) {

branches/tmp/src/doc/trpl/primitive-types.md

@@ -176,7 +176,7 @@ Slices have type `&[T]`. We’ll talk about that `T` when we cover
 
 [generics]: generics.html
 
-You can find more documentation for slices [in the standard library
+You can find more documentation for `slices`s [in the standard library
 documentation][slice].
 
 [slice]: ../std/primitive.slice.html

branches/tmp/src/doc/trpl/references-and-borrowing.md

@@ -6,7 +6,7 @@ become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own
 chapter:
 
-* [ownership][ownership], the key concept
+* [ownership][ownership], ownership, the key concept
 * borrowing, which you’re reading now
 * [lifetimes][lifetimes], an advanced concept of borrowing
 
@@ -312,7 +312,6 @@ println!("{}", y);
 
 We get this error:
 
-```text
 error: `x` does not live long enough
     y = &x;
          ^
@@ -335,37 +334,3 @@ In other words, `y` is only valid for the scope where `x` exists. As soon as
 `x` goes away, it becomes invalid to refer to it. As such, the error says that
 the borrow ‘doesn’t live long enough’ because it’s not valid for the right
 amount of time.
-
-The same problem occurs when the reference is declared _before_ the variable it refers to:
-
-```rust,ignore
-let y: &i32;
-let x = 5;
-y = &x;
-
-println!("{}", y);
-```
-
-We get this error:
-
-```text
-error: `x` does not live long enough
-y = &x;
-     ^
-note: reference must be valid for the block suffix following statement 0 at
-2:16...
-    let y: &i32;
-    let x = 5;
-    y = &x;
-    
-    println!("{}", y);
-}
-
-note: ...but borrowed value is only valid for the block suffix following
-statement 1 at 3:14
-    let x = 5;
-    y = &x;
-    
-    println!("{}", y);
-}
-```

branches/tmp/src/etc/CONFIGS.md

@@ -1,16 +1,10 @@
 # Configs
 
-These are some links to repos with configs which ease the use of rust.
-
-## Officially Maintained Configs
+Here are some links to repos with configs which ease the use of rust:
 
 * [rust.vim](https://github.com/rust-lang/rust.vim)
 * [emacs rust-mode](https://github.com/rust-lang/rust-mode)
 * [gedit-config](https://github.com/rust-lang/gedit-config)
 * [kate-config](https://github.com/rust-lang/kate-config)
 * [nano-config](https://github.com/rust-lang/nano-config)
 * [zsh-config](https://github.com/rust-lang/zsh-config)
-
-## Community-maintained Configs
-
-* [.editorconfig](https://gist.github.com/derhuerst/c9d1b9309e308d9851fa) ([what is this?](http://editorconfig.org/))

branches/tmp/src/etc/check-sanitycheck.py

@@ -13,6 +13,7 @@
 import os
 import sys
 import functools
+import resource
 
 STATUS = 0
 
@@ -36,7 +37,6 @@ def inner():
 
 @only_on(('linux', 'darwin', 'freebsd', 'openbsd'))
 def check_rlimit_core():
-    import resource
     soft, hard = resource.getrlimit(resource.RLIMIT_CORE)
     if soft > 0:
         error_unless_permitted('ALLOW_NONZERO_RLIMIT_CORE', """\

branches/tmp/src/libcollections/bit.rs

@@ -1796,89 +1796,6 @@ impl BitSet {
         self.other_op(other, |w1, w2| w1 ^ w2);
     }
 
-    /// Moves all elements from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_set_append_split_off)]
-    /// use std::collections::{BitVec, BitSet};
-    ///
-    /// let mut a = BitSet::new();
-    /// a.insert(2);
-    /// a.insert(6);
-    ///
-    /// let mut b = BitSet::new();
-    /// b.insert(1);
-    /// b.insert(3);
-    /// b.insert(6);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 4);
-    /// assert_eq!(b.len(), 0);
-    /// assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b01110010])));
-    /// ```
-    #[unstable(feature = "bit_set_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn append(&mut self, other: &mut Self) {
-        self.union_with(other);
-        other.clear();
-    }
-
-    /// Splits the `BitSet` into two at the given key including the key.
-    /// Retains the first part in-place while returning the second part.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_set_append_split_off)]
-    /// use std::collections::{BitSet, BitVec};
-    /// let mut a = BitSet::new();
-    /// a.insert(2);
-    /// a.insert(6);
-    /// a.insert(1);
-    /// a.insert(3);
-    ///
-    /// let b = a.split_off(3);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 2);
-    /// assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100000])));
-    /// assert_eq!(b, BitSet::from_bit_vec(BitVec::from_bytes(&[0b00010010])));
-    /// ```
-    #[unstable(feature = "bit_set_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        let mut other = BitSet::new();
-
-        if at == 0 {
-            swap(self, &mut other);
-            return other;
-        } else if at >= self.bit_vec.len() {
-            return other;
-        }
-
-        // Calculate block and bit at which to split
-        let w = at / u32::BITS;
-        let b = at % u32::BITS;
-
-        // Pad `other` with `w` zero blocks,
-        // append `self`'s blocks in the range from `w` to the end to `other`
-        other.bit_vec.storage.extend(repeat(0u32).take(w)
-                                     .chain(self.bit_vec.storage[w..].iter().cloned()));
-        other.bit_vec.nbits = self.bit_vec.nbits;
-
-        if b > 0 {
-            other.bit_vec.storage[w] &= !0 << b;
-        }
-
-        // Sets `bit_vec.len()` and fixes the last block as well
-        self.bit_vec.truncate(at);
-
-        other
-    }
-
     /// Returns the number of set bits in this set.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]

branches/tmp/src/libcollections/slice.rs

@@ -1002,7 +1002,7 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// The resulting type after concatenation
     type Output;
 
-    /// Flattens a slice of `T` into a single value `Self::Output`.
+    /// Flattens a slice of `T` into a single value `U`.
     ///
     /// # Examples
     ///
@@ -1012,8 +1012,7 @@ pub trait SliceConcatExt<T: ?Sized> {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn concat(&self) -> Self::Output;
 
-    /// Flattens a slice of `T` into a single value `Self::Output`, placing a given separator
-    /// between each.
+    /// Flattens a slice of `T` into a single value `U`, placing a given separator between each.
     ///
     /// # Examples
     ///

branches/tmp/src/libcollections/string.rs

@@ -1052,7 +1052,6 @@ impl<T: fmt::Display + ?Sized> ToString for T {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<str> for String {
-    #[inline]
     fn as_ref(&self) -> &str {
         self
     }