---

yaml
---
r: 214879
b: refs/heads/beta
c: b218470
h: refs/heads/master
i:
  214877: e0e9aeb
  214875: 4bf6bfa
  214871: ac26a07
  214863: 264191b
  214847: 33d140e
v: v3

Author: steveklabnik

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: ee1ba33c4c679e679b0fd95aaf7145e7ebc275d4
+refs/heads/beta: b218470b4d4c3a6fd2642044ecffc009aa99bd6c
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 8c0aa6d64ebab528f7eb182812007155d6044972
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/style/features/functions-and-methods/README.md

@@ -20,7 +20,6 @@ for any operation that is clearly associated with a particular
 type.
 
 Methods have numerous advantages over functions:
-
 * They do not need to be imported or qualified to be used: all you
   need is a value of the appropriate type.
 * Their invocation performs autoborrowing (including mutable borrows).

branches/beta/src/doc/style/features/functions-and-methods/input.md

@@ -159,7 +159,7 @@ fn foo(a: u8) { ... }
 Note that
 [`ascii::Ascii`](http://static.rust-lang.org/doc/master/std/ascii/struct.Ascii.html)
 is a _wrapper_ around `u8` that guarantees the highest bit is zero; see
-[newtype patterns](../types/newtype.md) for more details on creating typesafe wrappers.
+[newtype patterns]() for more details on creating typesafe wrappers.
 
 Static enforcement usually comes at little run-time cost: it pushes the
 costs to the boundaries (e.g. when a `u8` is first converted into an

branches/beta/src/doc/style/features/let.md

@@ -34,7 +34,7 @@ Prefer
 
 ```rust
 let foo = match bar {
-    Baz => 0,
+    Baz  => 0,
     Quux => 1
 };
 ```
@@ -44,7 +44,7 @@ over
 ```rust
 let foo;
 match bar {
-    Baz => {
+    Baz  => {
         foo = 0;
     }
     Quux => {
@@ -61,8 +61,8 @@ conditional expression.
 Prefer
 
 ```rust
-let v = s.iter().map(|x| x * 2)
-                .collect::<Vec<_>>();
+s.iter().map(|x| x * 2)
+        .collect::<Vec<_>>()
 ```
 
 over

branches/beta/src/doc/style/ownership/builders.md

@@ -16,7 +16,7 @@ If `T` is such a data structure, consider introducing a `T` _builder_:
    value. When possible, choose a better name: e.g. `Command` is the builder for
    `Process`.
 2. The builder constructor should take as parameters only the data _required_ to
-   make a `T`.
+   to make a `T`.
 3. The builder should offer a suite of convenient methods for configuration,
    including setting up compound inputs (like slices) incrementally.
    These methods should return `self` to allow chaining.

branches/beta/src/doc/trpl/README.md

@@ -15,7 +15,7 @@ language would.
 
 [rust]: http://rust-lang.org
 
-“The Rust Programming Language” is split into eight sections. This introduction
+“The Rust Programming Language” is split into seven sections. This introduction
 is the first. After this:
 
 * [Getting started][gs] - Set up your computer for Rust development.

branches/beta/src/doc/trpl/conditional-compilation.md

@@ -34,7 +34,7 @@ These can nest arbitrarily:
 As for how to enable or disable these switches, if you’re using Cargo,
 they get set in the [`[features]` section][features] of your `Cargo.toml`:
 
-[features]: http://doc.crates.io/manifest.html#the-%5Bfeatures%5D-section
+[features]: http://doc.crates.io/manifest.html#the-[features]-section
 
 ```toml
 [features]

branches/beta/src/doc/trpl/glossary.md

@@ -19,7 +19,7 @@ In the example above `x` and `y` have arity 2. `z` has arity 3.
 
 When a compiler is compiling your program, it does a number of different
 things. One of the things that it does is turn the text of your program into an
-‘abstract syntax tree’, or ‘AST’. This tree is a representation of the
+‘abstract syntax tree’, or‘AST’. This tree is a representation of the
 structure of your program. For example, `2 + 3` can be turned into a tree:
 
 ```text

branches/beta/src/doc/trpl/installing-rust.md

@@ -2,8 +2,12 @@
 
 The first step to using Rust is to install it! There are a number of ways to
 install Rust, but the easiest is to use the `rustup` script. If you're on Linux
-or a Mac, all you need to do is this (note that you don't need to type in the
-`$`s, they just indicate the start of each command):
+or a Mac, all you need to do is this: 
+
+> Note: you don't need to type in the `$`s, they just indicate the start of
+> each command. You’ll see many tutorials and examples around the web that
+> follow this convention: `$` for commands run as your regular user, and
+> `#` for commands you should be running as an administrator.
 
 ```bash
 $ curl -sf -L https://static.rust-lang.org/rustup.sh | sh

branches/beta/src/doc/trpl/lifetimes.md

@@ -134,29 +134,8 @@ x: &'a i32,
 # }
 ```
 
-uses it. So why do we need a lifetime here? We need to ensure that any reference
-to a `Foo` cannot outlive the reference to an `i32` it contains.
-
-If you have multiple references, you can use the same lifetime multiple times:
-
-```rust
-fn x_or_y<'a>(x: &'a str, y: &'a str) -> &'a str {
-#    x
-# }
-```
-
-This says that `x` and `y` both are alive for the same scope, and that the
-return value is also alive for that scope. If you wanted `x` and `y` to have
-different lifetimes, you can use multiple lifetime parameters:
-
-```rust
-fn x_or_y<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
-#    x
-# }
-```
-
-In this example, `x` and `y` have different valid scopes, but the return value
-has the same lifetime as `x`.
+uses it. So why do we need a lifetime here? We need to ensure that any
+reference to the contained `i32` does not outlive the containing `Foo`.
 
 ## Thinking in scopes
 

branches/beta/src/doc/trpl/method-syntax.md

@@ -4,7 +4,7 @@ Functions are great, but if you want to call a bunch of them on some data, it
 can be awkward. Consider this code:
 
 ```rust,ignore
-baz(bar(foo));
+baz(bar(foo)));
 ```
 
 We would read this left-to right, and so we see ‘baz bar foo’. But this isn’t the

branches/beta/src/doc/trpl/traits.md

@@ -285,7 +285,7 @@ fn bar<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug {
 
 fn main() {
     foo("Hello", "world");
-    bar("Hello", "world");
+    bar("Hello", "workd");
 }
 ```
 

branches/beta/src/libcollectionstest/lib.rs

@@ -14,7 +14,6 @@
 #![feature(collections)]
 #![feature(collections_drain)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(hash)]
 #![feature(rand)]
 #![feature(rustc_private)]

branches/beta/src/libcore/iter.rs

@@ -3030,100 +3030,6 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
     Repeat{element: elt}
 }
 
-/// An iterator that yields nothing.
-#[unstable(feature="iter_empty", reason = "new addition")]
-pub struct Empty<T>(marker::PhantomData<T>);
-
-#[unstable(feature="iter_empty", reason = "new addition")]
-impl<T> Iterator for Empty<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        None
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>){
-        (0, Some(0))
-    }
-}
-
-#[unstable(feature="iter_empty", reason = "new addition")]
-impl<T> DoubleEndedIterator for Empty<T> {
-    fn next_back(&mut self) -> Option<T> {
-        None
-    }
-}
-
-#[unstable(feature="iter_empty", reason = "new addition")]
-impl<T> ExactSizeIterator for Empty<T> {
-    fn len(&self) -> usize {
-        0
-    }
-}
-
-// not #[derive] because that adds a Clone bound on T,
-// which isn't necessary.
-#[unstable(feature="iter_empty", reason = "new addition")]
-impl<T> Clone for Empty<T> {
-    fn clone(&self) -> Empty<T> {
-        Empty(marker::PhantomData)
-    }
-}
-
-// not #[derive] because that adds a Default bound on T,
-// which isn't necessary.
-#[unstable(feature="iter_empty", reason = "new addition")]
-impl<T> Default for Empty<T> {
-    fn default() -> Empty<T> {
-        Empty(marker::PhantomData)
-    }
-}
-
-/// Creates an iterator that yields nothing.
-#[unstable(feature="iter_empty", reason = "new addition")]
-pub fn empty<T>() -> Empty<T> {
-    Empty(marker::PhantomData)
-}
-
-/// An iterator that yields an element exactly once.
-#[unstable(feature="iter_once", reason = "new addition")]
-pub struct Once<T> {
-    inner: ::option::IntoIter<T>
-}
-
-#[unstable(feature="iter_once", reason = "new addition")]
-impl<T> Iterator for Once<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        self.inner.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-#[unstable(feature="iter_once", reason = "new addition")]
-impl<T> DoubleEndedIterator for Once<T> {
-    fn next_back(&mut self) -> Option<T> {
-        self.inner.next_back()
-    }
-}
-
-#[unstable(feature="iter_once", reason = "new addition")]
-impl<T> ExactSizeIterator for Once<T> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-/// Creates an iterator that yields an element exactly once.
-#[unstable(feature="iter_once", reason = "new addition")]
-pub fn once<T>(value: T) -> Once<T> {
-    Once { inner: Some(value).into_iter() }
-}
-
 /// Functions for lexicographical ordering of sequences.
 ///
 /// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires

branches/beta/src/libcore/mem.rs

@@ -52,61 +52,20 @@ pub use intrinsics::transmute;
 /// * `mpsc::{Sender, Receiver}` cycles (they use `Arc` internally)
 /// * Panicking destructors are likely to leak local resources
 ///
-/// # When To Use
-///
-/// There's only a few reasons to use this function. They mainly come
-/// up in unsafe code or FFI code.
-///
-/// * You have an uninitialized value, perhaps for performance reasons, and
-///   need to prevent the destructor from running on it.
-/// * You have two copies of a value (like `std::mem::swap`), but need the
-///   destructor to only run once to prevent a double free.
-/// * Transferring resources across FFI boundries.
-///
 /// # Example
 ///
-/// Leak some heap memory by never deallocating it.
-///
-/// ```rust
+/// ```rust,no_run
 /// use std::mem;
+/// use std::fs::File;
 ///
+/// // Leak some heap memory by never deallocating it
 /// let heap_memory = Box::new(3);
 /// mem::forget(heap_memory);
-/// ```
-///
-/// Leak an I/O object, never closing the file.
-///
-/// ```rust,no_run
-/// use std::mem;
-/// use std::fs::File;
 ///
+/// // Leak an I/O object, never closing the file
 /// let file = File::open("foo.txt").unwrap();
 /// mem::forget(file);
 /// ```
-///
-/// The swap function uses forget to good effect.
-///
-/// ```rust
-/// use std::mem;
-/// use std::ptr;
-///
-/// fn swap<T>(x: &mut T, y: &mut T) {
-///     unsafe {
-///         // Give ourselves some scratch space to work with
-///         let mut t: T = mem::uninitialized();
-///
-///         // Perform the swap, `&mut` pointers never alias
-///         ptr::copy_nonoverlapping(&*x, &mut t, 1);
-///         ptr::copy_nonoverlapping(&*y, x, 1);
-///         ptr::copy_nonoverlapping(&t, y, 1);
-///
-///         // y and t now point to the same thing, but we need to completely
-///         // forget `t` because we do not want to run the destructor for `T`
-///         // on its value, which is still owned somewhere outside this function.
-///         mem::forget(t);
-///     }
-/// }
-/// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn forget<T>(t: T) {
     unsafe { intrinsics::forget(t) }
@@ -308,9 +267,8 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
         ptr::copy_nonoverlapping(&*y, x, 1);
         ptr::copy_nonoverlapping(&t, y, 1);
 
-        // y and t now point to the same thing, but we need to completely
-        // forget `t` because we do not want to run the destructor for `T`
-        // on its value, which is still owned somewhere outside this function.
+        // y and t now point to the same thing, but we need to completely forget `t`
+        // because it's no longer relevant.
         forget(t);
     }
 }

branches/beta/src/libcoretest/iter.rs

@@ -1096,19 +1096,6 @@ fn test_fuse_count() {
     // Can't check len now because count consumes.
 }
 
-#[test]
-fn test_once() {
-    let mut it = once(42);
-    assert_eq!(it.next(), Some(42));
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_empty() {
-    let mut it = empty::<i32>();
-    assert_eq!(it.next(), None);
-}
-
 #[bench]
 fn bench_rposition(b: &mut Bencher) {
     let it: Vec<usize> = (0..300).collect();

branches/beta/src/libcoretest/lib.rs

@@ -14,7 +14,6 @@
 #![feature(box_syntax)]
 #![feature(unboxed_closures)]
 #![feature(core)]
-#![feature(const_fn)]
 #![feature(test)]
 #![feature(rand)]
 #![feature(unicode)]
@@ -26,8 +25,6 @@
 #![feature(slice_patterns)]
 #![feature(float_from_str_radix)]
 #![feature(cell_extras)]
-#![feature(iter_empty)]
-#![feature(iter_once)]
 
 extern crate core;
 extern crate test;

branches/beta/src/liblibc/lib.rs

@@ -6043,6 +6043,7 @@ pub mod funcs {
         use types::common::c95::{c_void};
         use types::os::common::bsd44::{socklen_t, sockaddr, SOCKET};
         use types::os::arch::c95::c_int;
+        use types::os::arch::posix88::ssize_t;
 
         extern "system" {
             pub fn socket(domain: c_int, ty: c_int, protocol: c_int) -> SOCKET;
@@ -6067,7 +6068,7 @@ pub mod funcs {
                         flags: c_int) -> c_int;
             pub fn recvfrom(socket: SOCKET, buf: *mut c_void, len: c_int,
                             flags: c_int, addr: *mut sockaddr,
-                            addrlen: *mut c_int) -> c_int;
+                            addrlen: *mut c_int) -> ssize_t;
             pub fn sendto(socket: SOCKET, buf: *const c_void, len: c_int,
                           flags: c_int, addr: *const sockaddr,
                           addrlen: c_int) -> c_int;