Normalize indentation of switch statements.

Author: amartini51

Sources/TSPL/TSPL.docc/GuidedTour/GuidedTour.md

@@ -514,14 +514,14 @@ and tests for equality.
 ```swift
 let vegetable = "red pepper"
 switch vegetable {
-    case "celery":
-        print("Add some raisins and make ants on a log.")
-    case "cucumber", "watercress":
-        print("That would make a good tea sandwich.")
-    case let x where x.hasSuffix("pepper"):
-        print("Is it a spicy \(x)?")
-    default:
-        print("Everything tastes good in soup.")
+case "celery":
+    print("Add some raisins and make ants on a log.")
+case "cucumber", "watercress":
+    print("That would make a good tea sandwich.")
+case let x where x.hasSuffix("pepper"):
+    print("Is it a spicy \(x)?")
+default:
+    print("Everything tastes good in soup.")
 }
 // Prints "Is it a spicy red pepper?"
 ```
@@ -1461,16 +1461,16 @@ enum Rank: Int {
 
     func simpleDescription() -> String {
         switch self {
-            case .ace:
-                return "ace"
-            case .jack:
-                return "jack"
-            case .queen:
-                return "queen"
-            case .king:
-                return "king"
-            default:
-                return String(self.rawValue)
+        case .ace:
+            return "ace"
+        case .jack:
+            return "jack"
+        case .queen:
+            return "queen"
+        case .king:
+            return "king"
+        default:
+            return String(self.rawValue)
         }
     }
 }
@@ -1558,14 +1558,14 @@ enum Suit {
 
     func simpleDescription() -> String {
         switch self {
-            case .spades:
-                return "spades"
-            case .hearts:
-                return "hearts"
-            case .diamonds:
-                return "diamonds"
-            case .clubs:
-                return "clubs"
+        case .spades:
+            return "spades"
+        case .hearts:
+            return "hearts"
+        case .diamonds:
+            return "diamonds"
+        case .clubs:
+            return "clubs"
         }
     }
 }
@@ -1681,10 +1681,10 @@ let success = ServerResponse.result("6:00 am", "8:09 pm")
 let failure = ServerResponse.failure("Out of cheese.")
 
 switch success {
-    case let .result(sunrise, sunset):
-        print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
-    case let .failure(message):
-        print("Failure...  \(message)")
+case let .result(sunrise, sunset):
+    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
+case let .failure(message):
+    print("Failure...  \(message)")
 }
 // Prints "Sunrise is at 6:00 am and sunset is at 8:09 pm."
 ```

Sources/TSPL/TSPL.docc/LanguageGuide/ControlFlow.md

@@ -796,13 +796,13 @@ one or more values of the same type.
 
 ```
 switch <#some value to consider#> {
-   case <#value 1#>:
-      <#respond to value 1#>
-   case <#value 2#>,
-       <#value 3#>:
-      <#respond to value 2 or 3#>
-   default:
-      <#otherwise, do something else#>
+case <#value 1#>:
+    <#respond to value 1#>
+case <#value 2#>,
+    <#value 3#>:
+    <#respond to value 2 or 3#>
+default:
+    <#otherwise, do something else#>
 }
 ```
 
@@ -832,12 +832,12 @@ a single lowercase character called `someCharacter`:
 ```swift
 let someCharacter: Character = "z"
 switch someCharacter {
-    case "a":
-        print("The first letter of the alphabet")
-    case "z":
-        print("The last letter of the alphabet")
-    default:
-        print("Some other character")
+case "a":
+    print("The first letter of the alphabet")
+case "z":
+    print("The last letter of the alphabet")
+default:
+    print("Some other character")
 }
 // Prints "The last letter of the alphabet"
 ```
@@ -891,11 +891,11 @@ It isn't valid to write the following code, because the first case is empty:
 ```swift
 let anotherCharacter: Character = "a"
 switch anotherCharacter {
-    case "a": // Invalid, the case has an empty body
-    case "A":
-        print("The letter A")
-    default:
-        print("Not the letter A")
+case "a": // Invalid, the case has an empty body
+case "A":
+    print("The letter A")
+default:
+    print("Not the letter A")
 }
 // This will report a compile-time error.
 ```
@@ -936,10 +936,10 @@ separating the values with commas.
 ```swift
 let anotherCharacter: Character = "a"
 switch anotherCharacter {
-    case "a", "A":
-        print("The letter A")
-    default:
-        print("Not the letter A")
+case "a", "A":
+    print("The letter A")
+default:
+    print("Not the letter A")
 }
 // Prints "The letter A"
 ```
@@ -1050,16 +1050,16 @@ and categorizes it on the graph that follows the example.
 ```swift
 let somePoint = (1, 1)
 switch somePoint {
-    case (0, 0):
-        print("\(somePoint) is at the origin")
-    case (_, 0):
-        print("\(somePoint) is on the x-axis")
-    case (0, _):
-        print("\(somePoint) is on the y-axis")
-    case (-2...2, -2...2):
-        print("\(somePoint) is inside the box")
-    default:
-        print("\(somePoint) is outside of the box")
+case (0, 0):
+    print("\(somePoint) is at the origin")
+case (_, 0):
+    print("\(somePoint) is on the x-axis")
+case (0, _):
+    print("\(somePoint) is on the y-axis")
+case (-2...2, -2...2):
+    print("\(somePoint) is inside the box")
+default:
+    print("\(somePoint) is outside of the box")
 }
 // Prints "(1, 1) is inside the box"
 ```
@@ -1117,12 +1117,12 @@ and categorizes it on the graph that follows:
 ```swift
 let anotherPoint = (2, 0)
 switch anotherPoint {
-    case (let x, 0):
-        print("on the x-axis with an x value of \(x)")
-    case (0, let y):
-        print("on the y-axis with a y value of \(y)")
-    case let (x, y):
-        print("somewhere else at (\(x), \(y))")
+case (let x, 0):
+    print("on the x-axis with an x value of \(x)")
+case (0, let y):
+    print("on the y-axis with a y value of \(y)")
+case let (x, y):
+    print("somewhere else at (\(x), \(y))")
 }
 // Prints "on the x-axis with an x value of 2"
 ```
@@ -1182,12 +1182,12 @@ The example below categorizes an (x, y) point on the following graph:
 ```swift
 let yetAnotherPoint = (1, -1)
 switch yetAnotherPoint {
-    case let (x, y) where x == y:
-        print("(\(x), \(y)) is on the line x == y")
-    case let (x, y) where x == -y:
-        print("(\(x), \(y)) is on the line x == -y")
-    case let (x, y):
-        print("(\(x), \(y)) is just some arbitrary point")
+case let (x, y) where x == y:
+    print("(\(x), \(y)) is on the line x == y")
+case let (x, y) where x == -y:
+    print("(\(x), \(y)) is on the line x == -y")
+case let (x, y):
+    print("(\(x), \(y)) is just some arbitrary point")
 }
 // Prints "(1, -1) is on the line x == -y"
 ```
@@ -1240,13 +1240,13 @@ For example:
 ```swift
 let someCharacter: Character = "e"
 switch someCharacter {
-    case "a", "e", "i", "o", "u":
-        print("\(someCharacter) is a vowel")
-    case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
-        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
-        print("\(someCharacter) is a consonant")
-    default:
-        print("\(someCharacter) isn't a vowel or a consonant")
+case "a", "e", "i", "o", "u":
+    print("\(someCharacter) is a vowel")
+case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
+    "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
+    print("\(someCharacter) is a consonant")
+default:
+    print("\(someCharacter) isn't a vowel or a consonant")
 }
 // Prints "e is a vowel"
 ```
@@ -1289,10 +1289,10 @@ and that the value always has the same type.
 ```swift
 let stillAnotherPoint = (9, 0)
 switch stillAnotherPoint {
-    case (let distance, 0), (0, let distance):
-        print("On an axis, \(distance) from the origin")
-    default:
-        print("Not on an axis")
+case (let distance, 0), (0, let distance):
+    print("On an axis, \(distance) from the origin")
+default:
+    print("Not on an axis")
 }
 // Prints "On an axis, 9 from the origin"
 ```
@@ -1431,16 +1431,16 @@ For brevity, multiple values are covered in a single `switch` case.
 let numberSymbol: Character = "三"  // Chinese symbol for the number 3
 var possibleIntegerValue: Int?
 switch numberSymbol {
-    case "1", "١", "一", "๑":
-        possibleIntegerValue = 1
-    case "2", "٢", "二", "๒":
-        possibleIntegerValue = 2
-    case "3", "٣", "三", "๓":
-        possibleIntegerValue = 3
-    case "4", "٤", "四", "๔":
-        possibleIntegerValue = 4
-    default:
-        break
+case "1", "١", "一", "๑":
+    possibleIntegerValue = 1
+case "2", "٢", "二", "๒":
+    possibleIntegerValue = 2
+case "3", "٣", "三", "๓":
+    possibleIntegerValue = 3
+case "4", "٤", "四", "๔":
+    possibleIntegerValue = 4
+default:
+    break
 }
 if let integerValue = possibleIntegerValue {
     print("The integer value of \(numberSymbol) is \(integerValue).")
@@ -1520,11 +1520,11 @@ The example below uses `fallthrough` to create a textual description of a number
 let integerToDescribe = 5
 var description = "The number \(integerToDescribe) is"
 switch integerToDescribe {
-    case 2, 3, 5, 7, 11, 13, 17, 19:
-        description += " a prime number, and also"
-        fallthrough
-    default:
-        description += " an integer."
+case 2, 3, 5, 7, 11, 13, 17, 19:
+    description += " a prime number, and also"
+    fallthrough
+default:
+    description += " an integer."
 }
 print(description)
 // Prints "The number 5 is a prime number, and also an integer."
@@ -1664,16 +1664,16 @@ gameLoop: while square != finalSquare {
     diceRoll += 1
     if diceRoll == 7 { diceRoll = 1 }
     switch square + diceRoll {
-        case finalSquare:
-            // diceRoll will move us to the final square, so the game is over
-            break gameLoop
-        case let newSquare where newSquare > finalSquare:
-            // diceRoll will move us beyond the final square, so roll again
-            continue gameLoop
-        default:
-            // this is a valid move, so find out its effect
-            square += diceRoll
-            square += board[square]
+    case finalSquare:
+        // diceRoll will move us to the final square, so the game is over
+        break gameLoop
+    case let newSquare where newSquare > finalSquare:
+        // diceRoll will move us beyond the final square, so roll again
+        continue gameLoop
+    default:
+        // this is a valid move, so find out its effect
+        square += diceRoll
+        square += board[square]
     }
 }
 print("Game over!")