---

yaml
---
r: 154452
b: refs/heads/try2
c: e791032
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 9af4e325af28f6859bff1c1dd52c68a321dd337d
+refs/heads/try2: e7910322ccc4e4971dc2552959ccbbd7625286b0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

branches/try2/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:
@@ -3669,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/try2/src/doc/rust.md

@@ -169,6 +169,10 @@ 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
@@ -1801,7 +1805,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/try2/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/try2/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/try2/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,6 @@ 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)))
-    }
-}
 
 static TRUE: bool = true;
 static FALSE: bool = false;
@@ -985,7 +969,7 @@ impl<'a> RandomAccessIterator<bool> for Bits<'a> {
 /// assert!(bv.eq_vec([true, true, false, true,
 ///                    false, false, false, false]));
 /// ```
-#[deriving(Clone)]
+#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct BitvSet(Bitv);
 
 impl Default for BitvSet {
@@ -1008,32 +992,6 @@ 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());
-        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());
-        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());
-        iter::order::eq(a_iter, b_iter)
-    }
-}
-
-impl cmp::Eq for BitvSet {}
-
 impl BitvSet {
     /// Create a new bit vector set with initially no contents.
     ///
@@ -1183,18 +1141,10 @@ impl BitvSet {
         // Unwrap Bitvs
         let &BitvSet(ref mut self_bitv) = self;
         let &BitvSet(ref other_bitv) = other;
-
         // Expand the vector if necessary
         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
-        };
-
-        // Apply values found in other
-        for (i, w) in other_words {
+        // Apply values
+        for (i, w) in other_bitv.mask_words(0) {
             let old = self_bitv.storage[i];
             let new = f(old, w);
             *self_bitv.storage.get_mut(i) = new;
@@ -1521,7 +1471,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,82 +2213,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
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert!(a.is_empty());
-        assert!(b.is_empty());
-
-        // Uninitialized bits should behave like 0's
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::new();
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert!(a.is_empty());
-        assert!(b.is_empty());
-
-        // Standard
-        let mut a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let mut b = BitvSet::from_bitv(from_bytes([0b01100010]));
-        let c = a.clone();
-        a.intersect_with(&b);
-        b.intersect_with(&c);
-        assert_eq!(a.len(), 2);
-        assert_eq!(b.len(), 2);
-    }
-
-    #[test]
-    fn test_bitv_set_eq() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = BitvSet::new();
-
-        assert!(a == a);
-        assert!(a != b);
-        assert!(a != c);
-        assert!(b == b);
-        assert!(b == c);
-        assert!(c == c);
-    }
-
-    #[test]
-    fn test_bitv_set_cmp() {
-        let a = BitvSet::from_bitv(from_bytes([0b10100010]));
-        let b = BitvSet::from_bitv(from_bytes([0b00000000]));
-        let c = BitvSet::new();
-
-        assert_eq!(a.cmp(&b), Greater);
-        assert_eq!(a.cmp(&c), Greater);
-        assert_eq!(b.cmp(&a), Less);
-        assert_eq!(b.cmp(&c), Equal);
-        assert_eq!(c.cmp(&a), Less);
-        assert_eq!(c.cmp(&b), Equal);
-    }
-
     #[test]
     fn test_bitv_remove() {
         let mut a = BitvSet::new();

branches/try2/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/try2/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/try2/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/try2/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/try2/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/try2/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/try2/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/try2/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
     ///