Update for review comments.

Author: ehuss

src/expressions/if-expr.md

@@ -44,7 +44,7 @@ assert_eq!(y, "Bigger");
 
 > **<sup>Syntax</sup>**\
 > _IfLetExpression_ :\
-> &nbsp;&nbsp; `if` `let` [_Patterns_] `=` [_Expression_]<sub>_except struct or lazy boolean operator expression_</sub>
+> &nbsp;&nbsp; `if` `let` [_MatchArmPatterns_] `=` [_Expression_]<sub>_except struct or lazy boolean operator expression_</sub>
 >              [_BlockExpression_]\
 > &nbsp;&nbsp; (`else` (
 >   [_BlockExpression_]
@@ -152,7 +152,7 @@ if let PAT = ( EXPR || EXPR ) { .. }
 [_BlockExpression_]: expressions/block-expr.html
 [_Expression_]: expressions.html
 [_LazyBooleanOperatorExpression_]: expressions/operator-expr.html#lazy-boolean-operators
-[_Patterns_]: expressions/match-expr.html
+[_MatchArmPatterns_]: expressions/match-expr.html
 [_eRFCIfLetChain_]: https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md#rollout-plan-and-transitioning-to-rust-2018
 [`match` expression]: expressions/match-expr.html
 [scrutinee]: glossary.html#scrutinee

src/expressions/loop-expr.md

@@ -67,7 +67,7 @@ while i < 10 {
 
 > **<sup>Syntax</sup>**\
 > [_PredicatePatternLoopExpression_] :\
-> &nbsp;&nbsp; `while` `let` [_Patterns_] `=` [_Expression_]<sub>except struct expression</sub>
+> &nbsp;&nbsp; `while` `let` [_MatchArmPatterns_] `=` [_Expression_]<sub>except struct expression</sub>
 >              [_BlockExpression_]
 
 A `while let` loop is semantically similar to a `while` loop but in place of a
@@ -286,8 +286,8 @@ expression `()`.
 [LIFETIME_OR_LABEL]: tokens.html#lifetimes-and-loop-labels
 [_BlockExpression_]: expressions/block-expr.html
 [_Expression_]:      expressions.html
+[_MatchArmPatterns_]: expressions/match-expr.html
 [_Pattern_]: patterns.html
-[_Patterns_]: expressions/match-expr.html
 [`match` expression]: expressions/match-expr.html
 [scrutinee]: glossary.html#scrutinee
 [temporary values]: expressions.html#temporary-lifetimes

src/expressions/match-expr.md

@@ -15,9 +15,9 @@
 > &nbsp;&nbsp; _MatchArm_ `=>` ( [_BlockExpression_] | [_Expression_] ) `,`<sup>?</sup>
 >
 > _MatchArm_ :\
-> &nbsp;&nbsp; [_OuterAttribute_]<sup>\*</sup> _Patterns_ _MatchArmGuard_<sup>?</sup>
+> &nbsp;&nbsp; [_OuterAttribute_]<sup>\*</sup> _MatchArmPatterns_ _MatchArmGuard_<sup>?</sup>
 >
-> _Patterns_ :\
+> _MatchArmPatterns_ :\
 > &nbsp;&nbsp; `|`<sup>?</sup> [_Pattern_] ( `|` [_Pattern_] )<sup>\*</sup>
 >
 > _MatchArmGuard_ :\
@@ -76,9 +76,8 @@ let message = match x {
 assert_eq!(message, "a few");
 ```
 
-> Note: The `2..=9` is a [Range Pattern], not a [Range Expression] and, thus,
-> only those types of ranges supported by range patterns can be used in match
-> arms.
+> Note: The `2..=9` is a [Range Pattern], not a [Range Expression]. Thus, only
+> those types of ranges supported by range patterns can be used in match arms.
 
 Every binding in each `|` separated pattern must appear in all of the patterns
 in the arm. Every binding of the same name must have the same type, and have
@@ -109,15 +108,13 @@ let message = match maybe_digit {
 > and side effects it has to execute multiple times. For example:
 >
 > ```rust
-> use std::cell::Cell;
-> fn main() {
->     let i : Cell<i32> = Cell::new(0);
->     match 1 {
->         1 | _ if { i.set(i.get() + 1); false } => {}
->         _ => {}
->     }
->     assert_eq!(i.get(), 2);
+> # use std::cell::Cell;
+> let i : Cell<i32> = Cell::new(0);
+> match 1 {
+>     1 | _ if { i.set(i.get() + 1); false } => {}
+>     _ => {}
 > }
+> assert_eq!(i.get(), 2);
 > ```
 
 ## Attributes on match arms