Show examples that actually need 'case'

Co-authored-by: Doug Gregor <dgregor@apple.com>

Author: amartini51

TSPL.docc/LanguageGuide/ControlFlow.md

@@ -1459,18 +1459,19 @@ In this code,
 the condition for the `if` statement starts with `case`,
 indicating that the condition is a pattern instead of a Boolean value.
 If the pattern matches,
-the condition for the `if` is considered to be true,
-and the code in the body of the `if` statement runs.
+then the condition for the `if` is considered to be true,
+and so the code in the body of the `if` statement runs.
 The patterns you can write after `if case`
 are the same as the patterns you can write in a switch case.
 
-You can also use a pattern in a `for`-`in` loop,
-to give names to parts of the value using a value binding:
+In a `for`-`in` loop,
+you can give names to parts of the value using a value binding pattern,
+even without writing `case` in your code:
 
 ```swift
-let points = [(10, 0), (30, 100), (-20, 0)]
+let points = [(10, 0), (30, -30), (-20, 0)]
 
-for case let (x, y) in points {
+for (x, y) in points {
     if y == 0 {
         print("Found a point on the x-axis at \(x)")
     }
@@ -1484,29 +1485,47 @@ binding the first and second elements of the tuples
 to the `x` and `y` constants.
 The statements inside the loop can use those constants,
 like the `if` statement that checks whether the point lies on the x-axis.
-
-A `for`-`case`-`in` loop can also include a `where` clause,
-to check for an additional condition.
-The statements inside the loop run
-only when `where` clause matches the current element.
-For example,
-the `for`-`case`-`in` loop below is the same as the `for`-`in` loop above.
+A more concise way to write this code
+is to combine the value bindings and condition,
+using a `for`-`case`-`in` loop.
+The code below has the same behavior as the `for`-`in` loop above:
 
 ```swift
-for case let (x, y) in points where y == 0  {
+for case (let x, 0) in points {
     print("Found a point on the x-axis at \(x)")
 }
 // Prints "Found a point on the x-axis at 10"
 // Prints "Found a point on the x-axis at -20"
 ```
 
 In this code,
-the condition is integrated into the `for`-`case`-`in` loop as part of the pattern.
+the condition is integrated into the `for`-`case`-`in` loop
+as part of the pattern.
 The statements in the `for`-`case`-`in` loop run only for points on the x-axis.
 This code produces the same result as the `for`-`in` loop above,
 but is a more compact way to iterate
 over only certain elements in a collection.
 
+A `for`-`case`-`in` loop can also include a `where` clause,
+to check for an additional condition.
+The statements inside the loop run
+only when `where` clause matches the current element.
+For example:
+
+```swift
+for case let (x, y) in points where x == y || x == -y  {
+    print("Found (\(x), \(y)) along a line through the origin")
+}
+// Prints "Found (30, -30) along a line through the origin"
+```
+
+This code binds the first and second elements of the tuple
+to `x` and `y` as constants,
+and then checks their values in the `where` clause.
+If the `where` clause is `true`,
+then the code in the body of the `for` loop runs;
+otherwise, iteration continues with the next element.
+
 Because patterns can bind values,
 `if`-`case` statements and `for`-`case`-`in` loops
 are useful for working with enumerations that have associated values,