---

yaml
---
r: 128571
b: refs/heads/master
c: 08d7fc7
h: refs/heads/master
i:
  128569: 0c17a18
  128567: 18dcabf
v: v3

Author: wickerwaka

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b43596b43ed7084aff5954e5c4bdd0b2d52665e4
+refs/heads/master: 08d7fc76cf6b2fac291cecd7185af818940092e4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
 refs/heads/try: 414b31299172917f72458502d811da395f7b7b11

trunk/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.)

trunk/src/doc/complement-design-faq.md

@@ -1,6 +1,6 @@
 % The Rust Design FAQ
 
-This document describes decisions that were arrived at after lengthy discussion and
+This document describes decisions were arrived at after lengthy discussion and
 experimenting with alternatives. Please do not propose reversing them unless
 you have a new, extremely compelling argument. Note that this document
 specifically talks about the *language* and not any library or implementation.

trunk/src/doc/guide-ffi.md

@@ -263,13 +263,12 @@ Rust code:
 
 ~~~~no_run
 
-#[repr(C)]
 struct RustObject {
     a: i32,
     // other members
 }
 
-extern "C" fn callback(target: *mut RustObject, a:i32) {
+extern fn callback(target: *mut RustObject, a:i32) {
     println!("I'm called from C with value {0}", a);
     unsafe {
         // Update the value in RustObject with the value received from the callback
@@ -507,16 +506,16 @@ to define a block for all windows systems, not just x86 ones.
 
 # Interoperability with foreign code
 
-Rust guarantees that the layout of a `struct` is compatible with the platform's representation in C
-only if the `#[repr(C)]` attribute is applied to it.  `#[repr(C, packed)]` can be used to lay out
-struct members without padding.  `#[repr(C)]` can also be applied to an enum.
+Rust guarantees that the layout of a `struct` is compatible with the platform's representation in C.
+A `#[packed]` attribute is available, which will lay out the struct members without padding.
+However, there are currently no guarantees about the layout of an `enum`.
 
-Rust's owned boxes (`Box<T>`) use non-nullable pointers as handles which point to the contained
+Rust's owned and managed boxes use non-nullable pointers as handles which point to the contained
 object. However, they should not be manually created because they are managed by internal
-allocators. References can safely be assumed to be non-nullable pointers directly to the type.
-However, breaking the borrow checking or mutability rules is not guaranteed to be safe, so prefer
-using raw pointers (`*`) if that's needed because the compiler can't make as many assumptions about
-them.
+allocators. References can safely be assumed to be non-nullable pointers directly to the
+type. However, breaking the borrow checking or mutability rules is not guaranteed to be safe, so
+prefer using raw pointers (`*`) if that's needed because the compiler can't make as many assumptions
+about them.
 
 Vectors and strings share the same basic memory layout, and utilities are available in the `vec` and
 `str` modules for working with C APIs. However, strings are not terminated with `\0`. If you need a

trunk/src/doc/guide-pointers.md

@@ -332,7 +332,7 @@ let z = &x;
 Mutable ones, however, are not:
 
 ```{rust,ignore}
-let mut x = 5i;
+let x = 5i;
 let y = &mut x;
 let z = &mut x; // error: cannot borrow `x` as mutable more than once at a time
 ```

trunk/src/doc/guide-tasks.md

@@ -89,9 +89,10 @@ closure in the new task.
 fn print_message() { println!("I am running in a different task!"); }
 spawn(print_message);
 
-// Alternatively, use a `proc` expression instead of a named function.
+// Print something profound in a different task using a `proc` expression
 // The `proc` expression evaluates to an (unnamed) owned closure.
 // That closure will call `println!(...)` when the spawned task runs.
+
 spawn(proc() println!("I am also running in a different task!") );
 ~~~~
 
@@ -351,14 +352,14 @@ fn main() {
 
 The function `pnorm` performs a simple computation on the vector (it computes the sum of its items
 at the power given as argument and takes the inverse power of this value). The Arc on the vector is
-created by the line:
+created by the line
 
 ~~~
 # use std::rand;
 # use std::sync::Arc;
 # fn main() {
 # let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
-let numbers_arc = Arc::new(numbers);
+let numbers_arc=Arc::new(numbers);
 # }
 ~~~
 

trunk/src/doc/guide-unsafe.md

@@ -446,7 +446,7 @@ possible in two ways: the `#[start]` attribute, or overriding the
 default shim for the C `main` function with your own.
 
 The function marked `#[start]` is passed the command line parameters
-in the same format as C:
+in the same format as a C:
 
 ```
 #![no_std]
@@ -537,12 +537,11 @@ extern crate core;
 use core::prelude::*;
 
 use core::mem;
+use core::raw::Slice;
 
 #[no_mangle]
 pub extern fn dot_product(a: *const u32, a_len: u32,
                           b: *const u32, b_len: u32) -> u32 {
-    use core::raw::Slice;
-
     // Convert the provided arrays into Rust slices.
     // The core::raw module guarantees that the Slice
     // structure has the same memory layout as a &[T]
@@ -593,7 +592,7 @@ standard library itself.
 # Interacting with the compiler internals
 
 > **Note**: this section is specific to the `rustc` compiler; these
-> parts of the language may never be fully specified and so details may
+> parts of the language may never be full specified and so details may
 > differ wildly between implementations (and even versions of `rustc`
 > itself).
 >