Bulk replace 3 -> 4 space indents.

Used a sed script to make the changes:

    % cat indent.sed
    /```swift$/,/```/ s/^               \([^ ]\)/                    \1/g
    /```swift$/,/```/ s/^            \([^ ]\)/                \1/g
    /```swift$/,/```/ s/^         \([^ ]\)/            \1/g
    /```swift$/,/```/ s/^      \([^ ]\)/        \1/g
    /```swift$/,/```/ s/^   \([^ ]\)/    \1/g

Replacing the longer indents first reduces false positives where three
3-space indents gets turned into three 4-space indents, which then looks
like four 3-space indents and gets turned into four 4-space indents.
However, still will need to do a manual pass to back out places where
the 12 leading spaces were actually three 4s not four 3s.

Applied it to every file:

    % for f in **.md
    do
        sed -f indent.sed $f > out.tmp
        rm $f
        mv out.tmp $f
    done

Confirmed the only changes are spaces via 'git diff
--ignore-space-change' which has no output.

Author: amartini51

Sources/TSPL/TSPL.docc/LanguageGuide/AccessControl.md

@@ -230,25 +230,25 @@ the default access level of the type's members will be internal.
 
 ```swift
 public class SomePublicClass {                  // explicitly public class
-   public var somePublicProperty = 0            // explicitly public class member
-   var someInternalProperty = 0                 // implicitly internal class member
-   fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    public var somePublicProperty = 0            // explicitly public class member
+    var someInternalProperty = 0                 // implicitly internal class member
+    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 class SomeInternalClass {                       // implicitly internal class
-   var someInternalProperty = 0                 // implicitly internal class member
-   fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    var someInternalProperty = 0                 // implicitly internal class member
+    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 fileprivate class SomeFilePrivateClass {        // explicitly file-private class
-   func someFilePrivateMethod() {}              // implicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    func someFilePrivateMethod() {}              // implicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 private class SomePrivateClass {                // explicitly private class
-   func somePrivateMethod() {}                  // implicitly private class member
+    func somePrivateMethod() {}                  // implicitly private class member
 }
 ```
 
@@ -378,7 +378,7 @@ In fact, `someFunction()` won't compile as written below:
 
 ```swift
 func someFunction() -> (SomeInternalClass, SomePrivateClass) {
-   // function implementation goes here
+    // function implementation goes here
 }
 ```
 
@@ -410,7 +410,7 @@ for the function declaration to be valid:
 
 ```swift
 private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
-   // function implementation goes here
+    // function implementation goes here
 }
 ```
 
@@ -445,10 +445,10 @@ therefore also have an access level of public:
 
 ```swift
 public enum CompassPoint {
-   case north
-   case south
-   case east
-   case west
+    case north
+    case south
+    case east
+    case west
 }
 ```
 
@@ -668,11 +668,11 @@ the original implementation of `someMethod()`:
 
 ```swift
 public class A {
-   fileprivate func someMethod() {}
+    fileprivate func someMethod() {}
 }
 
 internal class B: A {
-   override internal func someMethod() {}
+    override internal func someMethod() {}
 }
 ```
 
@@ -700,13 +700,13 @@ or within the same module as the superclass for an internal member call):
 
 ```swift
 public class A {
-   fileprivate func someMethod() {}
+    fileprivate func someMethod() {}
 }
 
 internal class B: A {
-   override internal func someMethod() {
-      super.someMethod()
-   }
+    override internal func someMethod() {
+        super.someMethod()
+    }
 }
 ```
 
@@ -811,12 +811,12 @@ which keeps track of the number of times a string property is modified:
 
 ```swift
 struct TrackedString {
-   private(set) var numberOfEdits = 0
-   var value: String = "" {
-      didSet {
-         numberOfEdits += 1
-      }
-   }
+    private(set) var numberOfEdits = 0
+    var value: String = "" {
+        didSet {
+            numberOfEdits += 1
+        }
+    }
 }
 ```
 
@@ -923,13 +923,13 @@ by combining the `public` and `private(set)` access-level modifiers:
 
 ```swift
 public struct TrackedString {
-   public private(set) var numberOfEdits = 0
-   public var value: String = "" {
-      didSet {
-         numberOfEdits += 1
-      }
-   }
-   public init() {}
+    public private(set) var numberOfEdits = 0
+    public var value: String = "" {
+        didSet {
+            numberOfEdits += 1
+        }
+    }
+    public init() {}
 }
 ```
 

Sources/TSPL/TSPL.docc/LanguageGuide/AdvancedOperators.md

@@ -715,7 +715,7 @@ to add together instances of the `Vector2D` structure:
 
 ```swift
 struct Vector2D {
-   var x = 0.0, y = 0.0
+    var x = 0.0, y = 0.0
 }
 
 extension Vector2D {
@@ -989,7 +989,7 @@ You can now use this operator to check whether two `Vector2D` instances are equi
 let twoThree = Vector2D(x: 2.0, y: 3.0)
 let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
 if twoThree == anotherTwoThree {
-   print("These two vectors are equivalent.")
+    print("These two vectors are equivalent.")
 }
 // Prints "These two vectors are equivalent."
 ```
@@ -1047,10 +1047,10 @@ you add a type method called `+++` to `Vector2D` as follows:
 
 ```swift
 extension Vector2D {
-   static prefix func +++ (vector: inout Vector2D) -> Vector2D {
-      vector += vector
-      return vector
-   }
+    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
+        vector += vector
+        return vector
+    }
 }
 
 var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
@@ -1099,9 +1099,9 @@ which belongs to the precedence group `AdditionPrecedence`:
 ```swift
 infix operator +-: AdditionPrecedence
 extension Vector2D {
-   static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
-      return Vector2D(x: left.x + right.x, y: left.y - right.y)
-   }
+    static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
+        return Vector2D(x: left.x + right.x, y: left.y - right.y)
+    }
 }
 let firstVector = Vector2D(x: 1.0, y: 2.0)
 let secondVector = Vector2D(x: 3.0, y: 4.0)