---

yaml
---
r: 128931
b: refs/heads/try
c: 96f5eba
h: refs/heads/master
i:
  128929: 14888da
  128927: 7e009a5
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: ef0d49d78f91d6e517af2e37ed89a3e3587b9f83
+refs/heads/try: 96f5eba4f5603c612464d6b1e961677e9d7084d3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/guide.md

@@ -517,7 +517,7 @@ note: in expansion of format_args!
 <std macros>:1:1: 3:2 note: in expansion of println!
 src/hello_world.rs:4:5: 4:42 note: expansion site
 error: aborting due to previous error
-Could not compile `hello_world`.
+Could not execute process `rustc src/hello_world.rs --crate-type bin --out-dir /home/you/projects/hello_world/target -L /home/you/projects/hello_world/target -L /home/you/projects/hello_world/target/deps` (status=101)
 ```
 
 Rust will not let us use a value that has not been initialized. So why let us
@@ -532,7 +532,7 @@ in the middle of a string." We add a comma, and then `x`, to indicate that we
 want `x` to be the value we're interpolating. The comma is used to separate
 arguments we pass to functions and macros, if you're passing more than one.
 
-When you just use the curly braces, Rust will attempt to display the
+When you just use the double curly braces, Rust will attempt to display the
 value in a meaningful way by checking out its type. If you want to specify the
 format in a more detailed manner, there are a [wide number of options
 available](/std/fmt/index.html). For now, we'll just stick to the default:
@@ -1888,16 +1888,8 @@ fn main() {
 
 The first thing we changed was to `use std::rand`, as the docs
 explained.  We then added in a `let` expression to create a variable binding
-named `secret_number`, and we printed out its result.
-
-Also, you may wonder why we are using `%` on the result of `rand::random()`.
-This operator is called 'modulo', and it returns the remainder of a division.
-By taking the modulo of the result of `rand::random()`, we're limiting the
-values to be between 0 and 99. Then, we add one to the result, making it from 1
-to 100. Using modulo can give you a very, very small bias in the result, but
-for this example, it is not important.
-
-Let's try to compile this using `cargo build`:
+named `secret_number`, and we printed out its result. Let's try to compile
+this using `cargo build`:
 
 ```{notrust,no_run}
 $ cargo build
@@ -3677,9 +3669,10 @@ manually free this allocation! If we write
 ```
 
 then Rust will automatically free `x` at the end of the block. This isn't
-because Rust has a garbage collector -- it doesn't. Instead, when `x` goes out
-of scope, Rust `free`s `x`. This Rust code will do the same thing as the
-following C code:
+because Rust has a garbage collector -- it doesn't. Instead, Rust uses static
+analysis to determine the *lifetime* of `x`, and then generates code to free it
+once it's sure the `x` won't be used again. This Rust code will do the same
+thing as the following C code:
 
 ```{c,ignore}
 {

branches/try/src/doc/rust.md

@@ -169,10 +169,6 @@ sequence (`/**`), are interpreted as a special syntax for `doc`
 `#[doc="..."]` around the body of the comment (this includes the comment
 characters themselves, ie `/// Foo` turns into `#[doc="/// Foo"]`).
 
-`//!` comments apply to the parent of the comment, rather than the item that
-follows. `//!` comments are usually used to display information on the crate
-index page.
-
 Non-doc comments are interpreted as a form of whitespace.
 
 ## Whitespace
@@ -1805,7 +1801,7 @@ module through the rules above. It essentially allows public access into the
 re-exported item. For example, this program is valid:
 
 ~~~~
-pub use self::implementation as api;
+pub use api = self::implementation;
 
 mod implementation {
     pub fn f() {}

branches/try/src/doc/tutorial.md

@@ -3112,7 +3112,7 @@ use farm::*;
 However, that's not all. You can also rename an item while you're bringing it into scope:
 
 ~~~
-use farm::chicken as egg_layer;
+use egg_layer = farm::chicken;
 # mod farm { pub fn chicken() { println!("Laying eggs is fun!")  } }
 // ...
 
@@ -3335,7 +3335,7 @@ you just have to import it with an `use` statement.
 For example, it re-exports `range` which is defined in `std::iter::range`:
 
 ~~~
-use std::iter::range as iter_range;
+use iter_range = std::iter::range;
 
 fn main() {
     // `range` is imported by default

branches/try/src/liballoc/lib.rs

@@ -86,7 +86,7 @@ extern crate libc;
 
 #[deprecated = "use boxed instead"]
 #[cfg(not(test))]
-pub use boxed as owned;
+pub use owned = boxed;
 
 // Heaps provided for low-level allocation strategies
 

branches/try/src/libcollections/bitv.rs

@@ -66,7 +66,7 @@ use core::prelude::*;
 use core::cmp;
 use core::default::Default;
 use core::fmt;
-use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
+use core::iter::Take;
 use core::iter;
 use core::slice;
 use core::uint;
@@ -75,22 +75,25 @@ use std::hash;
 use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
-type MatchWords<'a> = Chain<MaskWords<'a>, Skip<Take<Enumerate<Repeat<uint>>>>>;
 // Take two BitV's, and return iterators of their words, where the shorter one
 // has been padded with 0's
-fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords<'b>) {
-    let a_len = a.storage.len();
-    let b_len = b.storage.len();
-
-    // have to uselessly pretend to pad the longer one for type matching
-    if a_len < b_len {
-        (a.mask_words(0).chain(Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
-         b.mask_words(0).chain(Repeat::new(0u).enumerate().take(0).skip(0)))
-    } else {
-        (a.mask_words(0).chain(Repeat::new(0u).enumerate().take(0).skip(0)),
-         b.mask_words(0).chain(Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
-    }
-}
+macro_rules! match_words(
+    ($a_expr:expr, $b_expr:expr) => ({
+        let a = $a_expr;
+        let b = $b_expr;
+        let a_len = a.storage.len();
+        let b_len = b.storage.len();
+
+        // have to uselessly pretend to pad the longer one for type matching
+        if a_len < b_len {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(b_len).skip(a_len)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)))
+        } else {
+            (a.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(0).skip(0)),
+             b.mask_words(0).chain(iter::Repeat::new(0u).enumerate().take(a_len).skip(b_len)))
+        }
+    })
+)
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -1011,23 +1014,23 @@ impl Extendable<bool> for BitvSet {
 impl PartialOrd for BitvSet {
     #[inline]
     fn partial_cmp(&self, other: &BitvSet) -> Option<Ordering> {
-        let (a_iter, b_iter) = match_words(self.get_ref(), other.get_ref());
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
         iter::order::partial_cmp(a_iter, b_iter)
     }
 }
 
 impl Ord for BitvSet {
     #[inline]
     fn cmp(&self, other: &BitvSet) -> Ordering {
-        let (a_iter, b_iter) = match_words(self.get_ref(), other.get_ref());
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
         iter::order::cmp(a_iter, b_iter)
     }
 }
 
 impl cmp::PartialEq for BitvSet {
     #[inline]
     fn eq(&self, other: &BitvSet) -> bool {
-        let (a_iter, b_iter) = match_words(self.get_ref(), other.get_ref());
+        let (a_iter, b_iter) = match_words!(self.get_ref(), other.get_ref());
         iter::order::eq(a_iter, b_iter)
     }
 }
@@ -1188,10 +1191,10 @@ impl BitvSet {
         self_bitv.reserve(other_bitv.capacity());
 
         // virtually pad other with 0's for equal lengths
-        let mut other_words = {
-            let (_, result) = match_words(self_bitv, other_bitv);
-            result
-        };
+        let self_len = self_bitv.storage.len();
+        let other_len =  other_bitv.storage.len();
+        let mut other_words = other_bitv.mask_words(0)
+         .chain(iter::Repeat::new(0u).enumerate().take(self_len).skip(other_len));
 
         // Apply values found in other
         for (i, w) in other_words {
@@ -1521,7 +1524,7 @@ impl Set<uint> for BitvSet {
 
     #[inline]
     fn is_disjoint(&self, other: &BitvSet) -> bool {
-        self.intersection(other).next().is_none()
+        self.intersection(other).count() > 0
     }
 
     #[inline]
@@ -2263,24 +2266,6 @@ mod tests {
         assert!(set1.is_subset(&set2)); // { 2 }  { 2, 4 }
     }
 
-    #[test]
-    fn test_bitv_set_is_disjoint() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b01000000]));
-        let c = BitvSet::new();
-        let d = BitvSet::from_bitv(from_bytes([0b00110000]));
-
-        assert!(!a.is_disjoint(&d));
-        assert!(!d.is_disjoint(&a));
-
-        assert!(a.is_disjoint(&b))
-        assert!(a.is_disjoint(&c))
-        assert!(b.is_disjoint(&a))
-        assert!(b.is_disjoint(&c))
-        assert!(c.is_disjoint(&a))
-        assert!(c.is_disjoint(&b))
-    }
-
     #[test]
     fn test_bitv_set_intersect_with() {
         // Explicitly 0'ed bits

branches/try/src/libcollections/hash/mod.rs

@@ -73,7 +73,7 @@ use core::mem;
 use vec::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
-pub use self::sip::hash as hash;
+pub use hash = self::sip::hash;
 
 pub mod sip;
 

branches/try/src/libcollections/str.rs

@@ -44,6 +44,17 @@ the string is valid for the `'static` lifetime, otherwise known as the
 lifetime of the entire program. As can be inferred from the type, these static
 strings are not mutable.
 
+# Mutability
+
+Many languages have immutable strings by default, and Rust has a particular
+flavor on this idea. As with the rest of Rust types, strings are immutable by
+default. If a string is declared as `mut`, however, it may be mutated. This
+works the same way as the rest of Rust's type system in the sense that if
+there's a mutable reference to a string, there may only be one mutable reference
+to that string. With these guarantees, strings can easily transition between
+being mutable/immutable with the same benefits of having mutable strings in
+other languages.
+
 # Representation
 
 Rust's string type, `str`, is a sequence of unicode scalar values encoded as a

branches/try/src/libcollections/string.rs

@@ -19,13 +19,13 @@ use core::fmt;
 use core::mem;
 use core::ptr;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
-use core::raw::Slice as RawSlice;
+use RawSlice = core::raw::Slice;
 
 use {Mutable, MutableSeq};
 use hash;
 use str;
 use str::{CharRange, StrAllocating, MaybeOwned, Owned};
-use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
+use MaybeOwnedSlice = str::Slice; // So many `Slice`s...
 use vec::Vec;
 
 /// A growable string stored as a UTF-8 encoded buffer.

branches/try/src/libcollections/vec.rs

@@ -13,13 +13,13 @@
 use core::prelude::*;
 
 use alloc::heap::{allocate, reallocate, deallocate};
+use RawSlice = core::raw::Slice;
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
 use core::mem;
 use core::num;
 use core::ptr;
-use core::raw::Slice as RawSlice;
 use core::uint;
 
 use {Mutable, MutableSeq};

branches/try/src/libcore/kinds.rs

@@ -21,7 +21,7 @@ by the compiler automatically for the types to which they apply.
 */
 
 #[deprecated = "This has been renamed to Sync"]
-pub use self::Sync as Share;
+pub use Share = self::Sync;
 
 /// Types able to be transferred across task boundaries.
 #[lang="send"]

branches/try/src/libcore/lib.rs

@@ -107,7 +107,7 @@ pub mod collections;
 /// Deprecated module in favor of `std::cell`
 pub mod ty {
     #[deprecated = "this type has been renamed to `UnsafeCell`"]
-    pub use cell::UnsafeCell as Unsafe;
+    pub use Unsafe = cell::UnsafeCell;
 }
 
 /* Core types and methods on primitives */

branches/try/src/libcore/num/mod.rs

@@ -1345,19 +1345,17 @@ checked_impl!(CheckedMul, checked_mul, i16, intrinsics::i16_mul_with_overflow)
 checked_impl!(CheckedMul, checked_mul, i32, intrinsics::i32_mul_with_overflow)
 checked_impl!(CheckedMul, checked_mul, i64, intrinsics::i64_mul_with_overflow)
 
-/// Performs division that returns `None` instead of failing on division by zero and instead of
-/// wrapping around on underflow and overflow.
+/// Performs division that returns `None` instead of wrapping around on underflow or overflow.
 pub trait CheckedDiv: Div<Self, Self> {
-    /// Divides two numbers, checking for underflow, overflow and division by zero. If any of that
-    /// happens, / `None` is returned.
+    /// Divides two numbers, checking for underflow or overflow. If underflow or overflow happens,
+    /// `None` is returned.
     ///
     /// # Example
     ///
     /// ```rust
     /// use std::num::CheckedDiv;
     /// assert_eq!((-127i8).checked_div(&-1), Some(127));
     /// assert_eq!((-128i8).checked_div(&-1), None);
-    /// assert_eq!((1i8).checked_div(&0), None);
     /// ```
     fn checked_div(&self, v: &Self) -> Option<Self>;
 }

branches/try/src/libcore/option.rs

@@ -244,7 +244,7 @@ impl<T> Option<T> {
         }
     }
 
-    /// Returns the inner `T` of a `Some(T)`.
+    /// Moves a value out of an option type and returns it, consuming the `Option`.
     ///
     /// # Failure
     ///

branches/try/src/libcore/slice.rs

@@ -50,7 +50,7 @@ use mem::size_of;
 use kinds::marker;
 use raw::Repr;
 // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
-use raw::Slice as RawSlice;
+use RawSlice = raw::Slice;
 
 
 //

branches/try/src/libgraphviz/lib.rs

@@ -47,7 +47,7 @@ forming a diamond-shaped acyclic graph and then pointing to the fifth
 which is cyclic.
 
 ```rust
-use graphviz as dot;
+use dot = graphviz;
 use graphviz::maybe_owned_vec::IntoMaybeOwnedVector;
 
 type Nd = int;
@@ -147,7 +147,7 @@ labelled with the ⊆ character (specified using the HTML character
 entity `&sube`).
 
 ```rust
-use graphviz as dot;
+use dot = graphviz;
 use std::str;
 
 type Nd = uint;
@@ -203,7 +203,7 @@ The output from this example is the same as the second example: the
 Hasse-diagram for the subsets of the set `{x, y}`.
 
 ```rust
-use graphviz as dot;
+use dot = graphviz;
 use std::str;
 
 type Nd<'a> = (uint, &'a str);

branches/try/src/libgreen/message_queue.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use alloc::arc::Arc;
-use std::sync::mpsc_queue as mpsc;
+use mpsc = std::sync::mpsc_queue;
 use std::kinds::marker;
 
 pub enum PopResult<T> {

branches/try/src/libgreen/sched.rs

@@ -25,7 +25,7 @@ use coroutine::Coroutine;
 use sleeper_list::SleeperList;
 use stack::StackPool;
 use task::{TypeSched, GreenTask, HomeSched, AnySched};
-use message_queue as msgq;
+use msgq = message_queue;
 
 /// A scheduler is responsible for coordinating the execution of Tasks
 /// on a single thread. The scheduler runs inside a slightly modified