Merge pull request #60759 from DevYeom/indentation_rst_files

Fix indentation of sample code in rst files.

Author: CodaFi

docs/OptimizationTips.rst

@@ -134,13 +134,13 @@ in the following ``C.array1`` and ``D.array1`` will be accessed directly
   }
 
   func usingC(_ c: C) {
-     c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
-     c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
+    c.array1[i] = ... // Can directly access C.array without going through dynamic dispatch.
+    c.doSomething() = ... // Can directly call C.doSomething without going through virtual dispatch.
   }
 
   func usingD(_ d: D) {
-     d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
-     d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
+    d.array1[i] = ... // Can directly access D.array1 without going through dynamic dispatch.
+    d.array2[i] = ... // Will access D.array2 through dynamic dispatch.
   }
 
 Advice: Use 'private' and 'fileprivate' when declaration does not need to be accessed outside of file
@@ -465,23 +465,23 @@ construct such a data structure:
 
   final class Ref<T> {
     var val: T
-    init(_ v: T) {val = v}
+    init(_ v: T) { val = v }
   }
 
   struct Box<T> {
-      var ref: Ref<T>
-      init(_ x: T) { ref = Ref(x) }
-
-      var value: T {
-          get { return ref.val }
-          set {
-            if !isKnownUniquelyReferenced(&ref) {
-              ref = Ref(newValue)
-              return
-            }
-            ref.val = newValue
-          }
+    var ref: Ref<T>
+    init(_ x: T) { ref = Ref(x) }
+
+    var value: T {
+      get { return ref.val }
+      set {
+        if !isKnownUniquelyReferenced(&ref) {
+          ref = Ref(newValue)
+          return
+        }
+        ref.val = newValue
       }
+    }
   }
 
 The type ``Box`` can replace the array in the code sample above.
@@ -501,9 +501,9 @@ count operations are expensive and unavoidable when using Swift classes.
 .. code-block:: swift
 
   final class Node {
-   var next: Node?
-   var data: Int
-   ...
+    var next: Node?
+    var data: Int
+    ...
   }
 
 
@@ -525,27 +525,27 @@ alive.
 
 .. code-block:: swift
 
-    // The call to ``withExtendedLifetime(Head)`` makes sure that the lifetime of
-    // Head is guaranteed to extend over the region of code that uses Unmanaged
-    // references. Because there exists a reference to Head for the duration
-    // of the scope and we don't modify the list of ``Node``s there also exist a
-    // reference through the chain of ``Head.next``, ``Head.next.next``, ...
-    // instances.
+  // The call to ``withExtendedLifetime(Head)`` makes sure that the lifetime of
+  // Head is guaranteed to extend over the region of code that uses Unmanaged
+  // references. Because there exists a reference to Head for the duration
+  // of the scope and we don't modify the list of ``Node``s there also exist a
+  // reference through the chain of ``Head.next``, ``Head.next.next``, ...
+  // instances.
 
-    withExtendedLifetime(Head) {
+  withExtendedLifetime(Head) {
 
-      // Create an Unmanaged reference.
-      var Ref: Unmanaged<Node> = Unmanaged.passUnretained(Head)
+    // Create an Unmanaged reference.
+    var Ref: Unmanaged<Node> = Unmanaged.passUnretained(Head)
 
-      // Use the unmanaged reference in a call/variable access. The use of
-      // _withUnsafeGuaranteedRef allows the compiler to remove the ultimate
-      // retain/release across the call/access.
+    // Use the unmanaged reference in a call/variable access. The use of
+    // _withUnsafeGuaranteedRef allows the compiler to remove the ultimate
+    // retain/release across the call/access.
 
-      while let Next = Ref._withUnsafeGuaranteedRef { $0.next } {
-        ...
-        Ref = Unmanaged.passUnretained(Next)
-      }
+    while let Next = Ref._withUnsafeGuaranteedRef { $0.next } {
+      ...
+      Ref = Unmanaged.passUnretained(Next)
     }
+  }
 
 
 .. _Unmanaged.swift: https://github.com/apple/swift/blob/main/stdlib/public/core/Unmanaged.swift

docs/proposals/Concurrency.rst

@@ -46,17 +46,17 @@ multi-threaded program below.
 
 .. code-block:: swift
 
-    import Foundation
+  import Foundation
 
-    let queue = DispatchQueue.global(qos: .default)
+  let queue = DispatchQueue.global(qos: .default)
 
-    class Bird {}
-    var single = Bird()
+  class Bird {}
+  var single = Bird()
 
-    queue.async {
-      while true { single = Bird() }
-    }
+  queue.async {
     while true { single = Bird() }
+  }
+  while true { single = Bird() }
 
 This program crashes very quickly when it tries to deallocate an already
 deallocated class instance.  To understand the bug try to imagine two threads
@@ -223,13 +223,13 @@ be called by worker-threads.
 
 .. code-block:: swift
 
-    func logger(_ x : Int) {
+  func logger(_ x : Int) {
 
-      // I know what I'm doing!
-      issafe {
-        glob = x
-      }
+    // I know what I'm doing!
+    issafe {
+      glob = x
     }
+  }
 
 
 Most protocols in the standard library, like `Incrementable` and `Equatable` are
@@ -324,20 +324,20 @@ This is an example of a tiny concurrent program that uses Tasks and Streams.
 
 .. code-block:: swift
 
-    let input  = Stream<String>()
-    let output = Stream<String>()
+  let input  = Stream<String>()
+  let output = Stream<String>()
 
-    func echoServer(_ inp : Stream<String>,
-                    out : Stream<String>) {
-      while true { out.push(inp.pop()) }
-    }
+  func echoServer(_ inp : Stream<String>,
+                  out : Stream<String>) {
+    while true { out.push(inp.pop()) }
+  }
 
-    createTask((input, output), callback: echoServer)
+  createTask((input, output), callback: echoServer)
 
-    for val in ["hello","world"] {
-      input.push(val)
-      print(output.pop())
-    }
+  for val in ["hello","world"] {
+    input.push(val)
+    print(output.pop())
+  }
 
 The program above creates a server task that accepts an input stream and an
 output stream that allows it to communicate with the main thread. The compiler
@@ -352,20 +352,20 @@ declaration of the streams in the closure.
 
 .. code-block:: swift
 
-     let comm : _Endpoint<String, Int> = createTask {
-       var counter = 0
-       while true {
-         $0.pop()
-         $0.push(counter)
-         counter += 1
-       }
-     }
-
-     // CHECK: 0, 1, 2,
-     for ss in ["","",""] {
-       comm.push(ss)
-       print("\(comm.pop()), ", terminator: "")
-     }
+  let comm : _Endpoint<String, Int> = createTask {
+    var counter = 0
+    while true {
+      $0.pop()
+      $0.push(counter)
+      counter += 1
+    }
+  }
+
+  // CHECK: 0, 1, 2,
+  for ss in ["","",""] {
+    comm.push(ss)
+    print("\(comm.pop()), ", terminator: "")
+  }
 
 Stream utilities
 ----------------
@@ -403,19 +403,19 @@ Example of a concurrent program using Futures in Swift.
 
 .. code-block:: swift
 
-    func mergeSort<T : Comparable>(array: ArraySlice<T>) -> [T] {
+  func mergeSort<T : Comparable>(array: ArraySlice<T>) -> [T] {
 
-      if array.count <= 16  { return Array(array).sorted() }
+    if array.count <= 16  { return Array(array).sorted() }
 
-      let mid = array.count / 2
-      let left  = array[0..<mid]
-      let right = array[mid..<array.count]
+    let mid = array.count / 2
+    let left  = array[0..<mid]
+    let right = array[mid..<array.count]
 
-      let lf = async(left,  callback: mergeSort)
-      let lr = async(right, callback: mergeSort)
+    let lf = async(left,  callback: mergeSort)
+    let lr = async(right, callback: mergeSort)
 
-      return merge(lf.await(), lr.await())
-    }
+    return merge(lf.await(), lr.await())
+  }
 
 The program above uses async to execute two tasks that sorts the two halves of
 the array in parallel.  Notice that the arrays in the example above are not
@@ -428,21 +428,21 @@ Here is another example of async calls using trailing closures and enums.
 
 .. code-block:: swift
 
-     enum Shape {
-       case circle, oval, square, triangle
-     }
+  enum Shape {
+    case circle, oval, square, triangle
+  }
 
-     let res = async(Shape.oval) { (c: Shape) -> String in
-       switch c {
-         case .circle:   return "Circle"
-         case .oval:     return "Oval"
-         case .square:   return "Square"
-         case .triangle: return "Triangle"
-       }
-     }
+  let res = async(Shape.oval) { (c: Shape) -> String in
+    switch c {
+      case .circle:   return "Circle"
+      case .oval:     return "Oval"
+      case .square:   return "Square"
+      case .triangle: return "Triangle"
+    }
+  }
 
-     //CHECK: Shape: Oval
-     print("Shape: \(res.await())")
+  //CHECK: Shape: Oval
+  print("Shape: \(res.await())")
 
 Notice that the swift compiler infers that ``Shape`` and `String` can be sent
 between the threads.
@@ -520,11 +520,11 @@ thread-safe (explained in the previous section). For example:
 
 .. code-block:: swift
 
-    @_semantics("swift.concurrent.async")
-    // This annotation tells the compiler to verify the closure and the passed arguments at the call site.
-    public func async<RetTy, ArgsTy>(args: ArgsTy, callback: @escaping (ArgsTy) -> RetTy) -> Future<RetTy> {
-      return unsafeAsync(args, callback: callback)
-    }
+  @_semantics("swift.concurrent.async")
+  // This annotation tells the compiler to verify the closure and the passed arguments at the call site.
+  public func async<RetTy, ArgsTy>(args: ArgsTy, callback: @escaping (ArgsTy) -> RetTy) -> Future<RetTy> {
+    return unsafeAsync(args, callback: callback)
+  }
 
 Example of shared data structures
 ---------------------------------