Update for review.

src/expressions/if-expr.md

@@ -53,11 +53,10 @@ assert_eq!(y, "Bigger");
 
 An `if let` expression is semantically similar to an `if` expression but in
 place of a condition expression it expects the keyword `let` followed by a
-pattern, an `=` and an expression. If the value of the expression on the right
-hand side of the `=` matches the pattern, the corresponding block will
-execute, otherwise flow proceeds to the following `else` block if it exists.
-Like `if` expressions, `if let` expressions have a value determined by the
-block that is evaluated.
+pattern, an `=` and a [scrutinee] expression. If the value of the scrutinee
+matches the pattern, the corresponding block will execute. Otherwise, flow
+proceeds to the following `else` block if it exists. Like `if` expressions,
+`if let` expressions have a value determined by the block that is evaluated.
 
 ```rust
 let dish = ("Ham", "Eggs");
@@ -75,8 +74,6 @@ if let ("Ham", b) = dish {
     println!("Ham is served with {}", b);
 }
 
-// Irrefutable patterns are allowed primarily to make it easier for macros to
-// accept any kind of pattern.
 if let _ = 5 {
     println!("Irrefutable patterns are always true");
 }
@@ -142,3 +139,4 @@ if let PAT = ( EXPR || EXPR ) { .. }
 [_Pattern_]: patterns.html
 [_LazyBooleanOperatorExpression_]: expressions/operator-expr.html#lazy-boolean-operators
 [_eRFCIfLetChain_]: https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md#rollout-plan-and-transitioning-to-rust-2018
+[scrutinee]: glossary.html#scrutinee

src/expressions/loop-expr.md

@@ -73,9 +73,9 @@ while i < 10 {
 A `while let` loop is semantically similar to a `while` loop but in place of a
 condition expression it expects the keyword `let` followed by a pattern, an
 `=`, a [scrutinee] expression and a block expression. If the value of the
-expression on the right hand side of the `=` matches the pattern, the loop
-body block executes then control returns to the pattern matching statement.
-Otherwise, the while expression completes.
+scrutinee matches the pattern, the loop body block executes then control
+returns to the pattern matching statement. Otherwise, the while expression
+completes.
 
 ```rust
 let mut x = vec![1, 2, 3];
@@ -84,8 +84,6 @@ while let Some(y) = x.pop() {
     println!("y = {}", y);
 }
 
-// Irrefutable patterns are allowed primarily to make it easier for macros to
-// accept any kind of pattern.
 while let _ = 5 {
     println!("Irrefutable patterns are always true");
     break;