Auto merge of #21473 - alexcrichton:rollup, r=alexcrichton

7 files changed, 18 insertions, 38 deletions

diff --git a/src/doc/intro.md b/src/doc/intro.md
index 3487738467f..b92d38215c2 100644
--- a/src/doc/intro.md
+++ b/src/doc/intro.md
@@ -480,14 +480,12 @@ use std::sync::{Arc,Mutex};
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
 
-    for i in 0..3 {
+    for i in 0us..3 {
         let number = numbers.clone();
         Thread::spawn(move || {
             let mut array = number.lock().unwrap();
-
-            (*array)[i] += 1;
-
-            println!("numbers[{}] is {}", i, (*array)[i]);
+            array[i] += 1;
+            println!("numbers[{}] is {}", i, array[i]);
         });
     }
 }
diff --git a/src/doc/reference.md b/src/doc/reference.md
index d3af4ab1c74..9ec4708eb2f 100644
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@@ -803,8 +803,9 @@ Crates contain [items](#items), each of which may have some number of
 ## Items
 
 ```{.ebnf .gram}
-item : mod_item | fn_item | type_item | struct_item | enum_item
-     | static_item | trait_item | impl_item | extern_block ;
+item : extern_crate_decl | use_decl | mod_item | fn_item | type_item
+     | struct_item | enum_item | static_item | trait_item | impl_item
+     | extern_block ;
 ```
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -818,6 +819,8 @@ execution, and may reside in read-only memory.
 
 There are several kinds of item:
 
+* [`extern crate` declarations](#extern-crate-declarations)
+* [`use` declarations](#use-declarations)
 * [modules](#modules)
 * [functions](#functions)
 * [type definitions](#type-definitions)
@@ -854,13 +857,10 @@ no notion of type abstraction: there are no first-class "forall" types.
 
 ```{.ebnf .gram}
 mod_item : "mod" ident ( ';' | '{' mod '}' );
-mod : [ view_item | item ] * ;
+mod : item * ;
 ```
 
-A module is a container for zero or more [view items](#view-items) and zero or
-more [items](#items). The view items manage the visibility of the items defined
-within the module, as well as the visibility of names from outside the module
-when referenced from inside the module.
+A module is a container for zero or more [items](#items).
 
 A _module item_ is a module, surrounded in braces, named, and prefixed with the
 keyword `mod`. A module item introduces a new, named module into the tree of
@@ -918,19 +918,6 @@ mod thread {
 }
 ```
 
-#### View items
-
-```{.ebnf .gram}
-view_item : extern_crate_decl | use_decl ;
-```
-
-A view item manages the namespace of a module. View items do not define new
-items, but rather, simply change other items' visibility. There are two
-kinds of view items:
-
-* [`extern crate` declarations](#extern-crate-declarations)
-* [`use` declarations](#use-declarations)
-
 ##### Extern crate declarations
 
 ```{.ebnf .gram}
@@ -2377,10 +2364,6 @@ These types help drive the compiler's analysis
   : ___Needs filling in___
 * `no_copy_bound`
   : This type does not implement "copy", even if eligible.
-* `no_send_bound`
-  : This type does not implement "send", even if eligible.
-* `no_sync_bound`
-  : This type does not implement "sync", even if eligible.
 * `eh_personality`
   : ___Needs filling in___
 * `exchange_free`
@@ -2891,13 +2874,12 @@ Point3d {y: 0, z: 10, .. base};
 ### Block expressions
 
 ```{.ebnf .gram}
-block_expr : '{' [ view_item ] *
-                 [ stmt ';' | item ] *
+block_expr : '{' [ stmt ';' | item ] *
                  [ expr ] '}' ;
 ```
 
 A _block expression_ is similar to a module in terms of the declarations that
-are possible. Each block conceptually introduces a new namespace scope. View
+are possible. Each block conceptually introduces a new namespace scope. Use
 items can bring new names into scopes and declared items are in scope for only
 the block itself.
 
diff --git a/src/doc/trpl/crates-and-modules.md b/src/doc/trpl/crates-and-modules.md
index 25870d84a75..79bb5c182f4 100644
--- a/src/doc/trpl/crates-and-modules.md
+++ b/src/doc/trpl/crates-and-modules.md
@@ -257,7 +257,7 @@ fn goodbye() -> String {
 
 (This is "Sayōnara", if you're curious.)
 
-Now that we have our some functionality in our crate, let's try to use it from
+Now that we have some functionality in our crate, let's try to use it from
 another crate.
 
 # Importing External Crates
diff --git a/src/doc/trpl/if.md b/src/doc/trpl/if.md
index ea1da167458..a350df67b17 100644
--- a/src/doc/trpl/if.md
+++ b/src/doc/trpl/if.md
@@ -1,4 +1,4 @@
-% `if`
+% If
 
 Rust's take on `if` is not particularly complex, but it's much more like the
 `if` you'll find in a dynamically typed language than in a more traditional
diff --git a/src/doc/trpl/looping.md b/src/doc/trpl/looping.md
index 28f02b1ffe1..4301149d1f8 100644
--- a/src/doc/trpl/looping.md
+++ b/src/doc/trpl/looping.md
@@ -123,7 +123,7 @@ We now loop forever with `loop` and use `break` to break out early.
 iteration. This will only print the odd numbers:
 
 ```{rust}
-for x in 0..10 {
+for x in 0u32..10 {
     if x % 2 == 0 { continue; }
 
     println!("{}", x);
diff --git a/src/doc/trpl/threads.md b/src/doc/trpl/threads.md
index 1bad09b4b6e..a801a1ab0e9 100644
--- a/src/doc/trpl/threads.md
+++ b/src/doc/trpl/threads.md
@@ -179,7 +179,7 @@ for init_val in 0 .. 3 {
 }
 
 let result = rx.recv().unwrap() + rx.recv().unwrap() + rx.recv().unwrap();
-# fn some_expensive_computation(_i: u32) -> u32 { 42 }
+# fn some_expensive_computation(_i: i32) -> i32 { 42 }
 ```
 
 Cloning a `Sender` produces a new handle to the same channel, allowing multiple
@@ -207,7 +207,7 @@ let rxs = (0 .. 3).map(|&:init_val| {
 
 // Wait on each port, accumulating the results
 let result = rxs.iter().fold(0, |&:accum, rx| accum + rx.recv().unwrap() );
-# fn some_expensive_computation(_i: u32) -> u32 { 42 }
+# fn some_expensive_computation(_i: i32) -> i32 { 42 }
 ```
 
 ## Backgrounding computations: Futures
diff --git a/src/doc/trpl/unsafe.md b/src/doc/trpl/unsafe.md
index 2a66b4a01f7..3acd1eefe89 100644
--- a/src/doc/trpl/unsafe.md
+++ b/src/doc/trpl/unsafe.md
@@ -707,7 +707,7 @@ Other features provided by lang items include:
   various kinds; lang items `send`, `sync` and `copy`.
 - the marker types and variance indicators found in
   `std::marker`; lang items `covariant_type`,
-  `contravariant_lifetime`, `no_sync_bound`, etc.
+  `contravariant_lifetime`, etc.
 
 Lang items are loaded lazily by the compiler; e.g. if one never uses
 `Box` then there is no need to define functions for `exchange_malloc`