---

yaml
---
r: 207927
b: refs/heads/snap-stage3
c: ede7a6d
h: refs/heads/master
i:
  207925: 435fae8
  207923: ad53cac
  207919: 285291f
v: v3

Author: Manishearth

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 82158c9d1cc97d03b7e3a48fda0ff8c1e9209041
+refs/heads/snap-stage3: ede7a6dc8ff5455f9d0d39a90e6d11e9a374e93b
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/doc/reference.md

@@ -1557,7 +1557,8 @@ warnings are generated, or otherwise "you used a private item of another module
 and weren't allowed to."
 
 By default, everything in Rust is *private*, with one exception. Enum variants
-in a `pub` enum are also public by default. When an item is declared as `pub`,
+in a `pub` enum are also public by default. You are allowed to alter this
+default visibility with the `priv` keyword. When an item is declared as `pub`,
 it can be thought of as being accessible to the outside world. For example:
 
 ```
@@ -2425,18 +2426,11 @@ Tuples are written by enclosing zero or more comma-separated expressions in
 parentheses. They are used to create [tuple-typed](#tuple-types) values.
 
 ```{.tuple}
+(0,);
 (0.0, 4.5);
 ("a", 4usize, true);
 ```
 
-You can disambiguate a single-element tuple from a value in parentheses with a
-comma:
-
-```
-(0,); // single-element tuple
-(0); // zero in parentheses
-```
-
 ### Unit expressions
 
 The expression `()` denotes the _unit value_, the only value of the type with

branches/snap-stage3/src/doc/trpl/README.md

@@ -190,5 +190,5 @@ fn main() {
 We created an inner scope with an additional set of curly braces. `y` will go out of
 scope before we call `push()`, and so we’re all good.
 
-This concept of ownership isn’t just good for preventing dangling pointers, but an
+This concept of ownership isn’t just good for preventing danging pointers, but an
 entire set of related problems, like iterator invalidation, concurrency, and more.

branches/snap-stage3/src/doc/trpl/attributes.md

@@ -67,4 +67,4 @@ Rust attributes are used for a number of different things. There is a full list
 of attributes [in the reference][reference]. Currently, you are not allowed to
 create your own attributes, the Rust compiler defines them.
 
-[reference]: ../reference.html#attributes
+[reference]: reference.html#attributes

branches/snap-stage3/src/doc/trpl/const-and-static.md

@@ -19,16 +19,18 @@ this reason.
 # `static`
 
 Rust provides a ‘global variable’ sort of facility in static items. They’re
-similar to constants, but static items aren’t inlined upon use. This means that
-there is only one instance for each value, and it’s at a fixed location in
-memory.
+similar to [constants][const], but static items aren’t inlined upon use. This
+means that there is only one instance for each value, and it’s at a fixed
+location in memory.
 
 Here’s an example:
 
 ```rust
 static N: i32 = 5;
 ```
 
+[const]: const.html
+
 Unlike [`let`][let] bindings, you must annotate the type of a `static`.
 
 [let]: variable-bindings.html

branches/snap-stage3/src/doc/trpl/iterators.md

@@ -235,15 +235,26 @@ Ranges are one of two basic iterators that you'll see. The other is `iter()`.
 in turn:
 
 ```rust
-let nums = vec![1, 2, 3];
+let nums = [1, 2, 3];
 
 for num in nums.iter() {
    println!("{}", num);
 }
 ```
 
 These two basic iterators should serve you well. There are some more
-advanced iterators, including ones that are infinite.
+advanced iterators, including ones that are infinite. Like using range syntax
+and `step_by`:
+
+```rust
+# #![feature(step_by)]
+(1..).step_by(5);
+```
+
+This iterator counts up from one, adding five each time. It will give
+you a new integer every time, forever (well, technically, until it reaches the
+maximum number representable by an `i32`). But since iterators are lazy,
+that's okay! You probably don't want to use `collect()` on it, though...
 
 That's enough about iterators. Iterator adapters are the last concept
 we need to talk about with regards to iterators. Let's get to it!

branches/snap-stage3/src/doc/trpl/nightly-rust.md

@@ -93,7 +93,8 @@ If not, there are a number of places where you can get help. The easiest is
 [the #rust IRC channel on irc.mozilla.org][irc], which you can access through
 [Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans
 (a silly nickname we call ourselves), and we can help you out. Other great
-resources include [the user’s forum][users], and [Stack Overflow][stack overflow].
+resources include [the user’s forum][users], and [Stack Overflow][stack
+overflow].
 
 [irc]: irc://irc.mozilla.org/#rust
 [mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust

branches/snap-stage3/src/doc/trpl/primitive-types.md

@@ -248,14 +248,6 @@ or “breaks up” the tuple, and assigns the bits to three bindings.
 
 This pattern is very powerful, and we’ll see it repeated more later.
 
-You can disambiguate a single-element tuple from a value in parentheses with a
-comma:
-
-```
-(0,); // single-element tuple
-(0); // zero in parentheses
-```
-
 ## Tuple Indexing
 
 You can also access fields of a tuple with indexing syntax:

branches/snap-stage3/src/doc/trpl/raw-pointers.md

@@ -80,7 +80,7 @@ Raw pointers are useful for FFI: Rust’s `*const T` and `*mut T` are similar to
 C’s `const T*` and `T*`, respectfully. For more about this use, consult the
 [FFI chapter][ffi].
 
-[ffi]: ffi.html
+[ffi]: ffi.md
 
 # References and raw pointers
 

branches/snap-stage3/src/doc/trpl/unsafe.md

@@ -101,7 +101,7 @@ Rust has a feature called ‘`static mut`’ which allows for mutable global sta
 Doing so can cause a data race, and as such is inherently not safe. For more
 details, see the [static][static] section of the book.
 
-[static]: const-and-static.html#static
+[static]: static.html
 
 ## Dereference a raw pointer
 

branches/snap-stage3/src/doc/trpl/unsized-types.md

@@ -38,11 +38,9 @@ impl Foo for &str {
 ```
 
 Meaning, this implementation would only work for [references][ref], and not
-other types of pointers. With the `impl for str`, all pointers, including (at
-some point, there are some bugs to fix first) user-defined custom smart
-pointers, can use this `impl`.
-
-[ref]: references-and-borrowing.html
+other types of pointers. With this `impl`, all pointers, including (at some
+point, there are some bugs to fix first) user-defined custom smart pointers,
+can use this `impl`.
 
 # ?Sized
 

branches/snap-stage3/src/liballoc/boxed.rs

@@ -240,7 +240,6 @@ impl<T: ?Sized + Hash> Hash for Box<T> {
 impl Box<Any> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    /// Attempt to downcast the box to a concrete type.
     pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {
@@ -258,15 +257,11 @@ impl Box<Any> {
     }
 }
 
-impl Box<Any + Send> {
+impl Box<Any+Send> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    /// Attempt to downcast the box to a concrete type.
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any + Send>> {
-        <Box<Any>>::downcast(self).map_err(|s| unsafe {
-            // reapply the Send marker
-            mem::transmute::<Box<Any>, Box<Any + Send>>(s)
-        })
+    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+        <Box<Any>>::downcast(self)
     }
 }
 

branches/snap-stage3/src/libcollections/fmt.rs

@@ -398,7 +398,7 @@
 //! longer than this width, then it is truncated down to this many characters and only those are
 //! emitted.
 //!
-//! For integral types, this is ignored.
+//! For integral types, this has no meaning currently.
 //!
 //! For floating-point types, this indicates how many digits after the decimal point should be
 //! printed.

branches/snap-stage3/src/libcollections/string.rs

@@ -26,8 +26,7 @@ use rustc_unicode::str as unicode_str;
 use rustc_unicode::str::Utf16Item;
 
 use borrow::{Cow, IntoCow};
-use range::RangeArgument;
-use str::{self, FromStr, Utf8Error, Chars};
+use str::{self, FromStr, Utf8Error};
 use vec::{DerefVec, Vec, as_vec};
 
 /// A growable string stored as a UTF-8 encoded buffer.
@@ -696,59 +695,6 @@ impl String {
     pub fn clear(&mut self) {
         self.vec.clear()
     }
-
-    /// Create a draining iterator that removes the specified range in the string
-    /// and yields the removed chars from start to end. The element range is
-    /// removed even if the iterator is not consumed until the end.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point or end point are not on character boundaries,
-    /// or if they are out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections_drain)]
-    ///
-    /// let mut s = String::from("α is alpha, β is beta");
-    /// let beta_offset = s.find('β').unwrap_or(s.len());
-    ///
-    /// // Remove the range up until the β from the string
-    /// let t: String = s.drain(..beta_offset).collect();
-    /// assert_eq!(t, "α is alpha, ");
-    /// assert_eq!(s, "β is beta");
-    ///
-    /// // A full range clears the string
-    /// s.drain(..);
-    /// assert_eq!(s, "");
-    /// ```
-    #[unstable(feature = "collections_drain",
-               reason = "recently added, matches RFC")]
-    pub fn drain<R>(&mut self, range: R) -> Drain where R: RangeArgument<usize> {
-        // Memory safety
-        //
-        // The String version of Drain does not have the memory safety issues
-        // of the vector version. The data is just plain bytes.
-        // Because the range removal happens in Drop, if the Drain iterator is leaked,
-        // the removal will not happen.
-        let len = self.len();
-        let start = *range.start().unwrap_or(&0);
-        let end = *range.end().unwrap_or(&len);
-
-        // Take out two simultaneous borrows. The &mut String won't be accessed
-        // until iteration is over, in Drop.
-        let self_ptr = self as *mut _;
-        // slicing does the appropriate bounds checks
-        let chars_iter = self[start..end].chars();
-
-        Drain {
-            start: start,
-            end: end,
-            iter: chars_iter,
-            string: self_ptr,
-        }
-    }
 }
 
 impl FromUtf8Error {
@@ -794,7 +740,8 @@ impl<'a> FromIterator<&'a str> for String {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "collections",
+           reason = "waiting on Extend stabilization")]
 impl Extend<char> for String {
     fn extend<I: IntoIterator<Item=char>>(&mut self, iterable: I) {
         let iterator = iterable.into_iter();
@@ -806,7 +753,8 @@ impl Extend<char> for String {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "collections",
+           reason = "waiting on Extend stabilization")]
 impl<'a> Extend<&'a str> for String {
     fn extend<I: IntoIterator<Item=&'a str>>(&mut self, iterable: I) {
         let iterator = iterable.into_iter();
@@ -921,7 +869,8 @@ impl hash::Hash for String {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "collections",
+           reason = "recent addition, needs more experience")]
 impl<'a> Add<&'a str> for String {
     type Output = String;
 
@@ -1015,17 +964,11 @@ pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
     DerefString { x: as_vec(x.as_bytes()) }
 }
 
-/// Error returned from `String::from_str`
-#[unstable(feature = "str_parse_error", reason = "may want to be replaced with \
-                                                  Void if it ever exists")]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct ParseError(());
-
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "collections", reason = "associated error type may change")]
 impl FromStr for String {
-    type Err = ParseError;
+    type Err = ();
     #[inline]
-    fn from_str(s: &str) -> Result<String, ParseError> {
+    fn from_str(s: &str) -> Result<String, ()> {
         Ok(String::from_str(s))
     }
 }
@@ -1129,55 +1072,3 @@ impl fmt::Write for String {
         Ok(())
     }
 }
-
-/// A draining iterator for `String`.
-#[unstable(feature = "collections_drain", reason = "recently added")]
-pub struct Drain<'a> {
-    /// Will be used as &'a mut String in the destructor
-    string: *mut String,
-    /// Start of part to remove
-    start: usize,
-    /// End of part to remove
-    end: usize,
-    /// Current remaining range to remove
-    iter: Chars<'a>,
-}
-
-unsafe impl<'a> Sync for Drain<'a> {}
-unsafe impl<'a> Send for Drain<'a> {}
-
-#[unstable(feature = "collections_drain", reason = "recently added")]
-impl<'a> Drop for Drain<'a> {
-    fn drop(&mut self) {
-        unsafe {
-            // Use Vec::drain. "Reaffirm" the bounds checks to avoid
-            // panic code being inserted again.
-            let self_vec = (*self.string).as_mut_vec();
-            if self.start <= self.end && self.end <= self_vec.len() {
-                self_vec.drain(self.start..self.end);
-            }
-        }
-    }
-}
-
-#[unstable(feature = "collections_drain", reason = "recently added")]
-impl<'a> Iterator for Drain<'a> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        self.iter.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[unstable(feature = "collections_drain", reason = "recently added")]
-impl<'a> DoubleEndedIterator for Drain<'a> {
-    #[inline]
-    fn next_back(&mut self) -> Option<char> {
-        self.iter.next_back()
-    }
-}