Document irrefutable_let_patterns

Author: ehuss

src/expressions/if-expr.md

@@ -53,11 +53,11 @@ 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
-refutable 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 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.
 
 ```rust
 let dish = ("Ham", "Eggs");
@@ -74,6 +74,12 @@ if let ("Bacon", b) = dish {
 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");
+}
 ```
 
 `if` and `if let` expressions can be intermixed:

src/expressions/loop-expr.md

@@ -19,7 +19,7 @@ Rust supports four loop expressions:
 
 *   A [`loop` expression](#infinite-loops) denotes an infinite loop.
 *   A [`while` expression](#predicate-loops) loops until a predicate is false.
-*   A [`while let` expression](#predicate-pattern-loops) tests a refutable pattern.
+*   A [`while let` expression](#predicate-pattern-loops) tests a pattern.
 *   A [`for` expression](#iterator-loops) extracts values from an iterator,
     looping until the iterator is empty.
 
@@ -71,9 +71,9 @@ while i < 10 {
 >              [_BlockExpression_]
 
 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 refutable
-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
+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.
 
@@ -83,6 +83,13 @@ let mut x = vec![1, 2, 3];
 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;
+}
 ```
 
 A `while let` loop is equivalent to a `loop` expression containing a `match`