Fix formatting for swift code blocks.

Author: tjw

proposals/NNNN-autoreleasepool-signature.md

@@ -30,42 +30,44 @@ accidentally unwrapping a `nil` value.
 
 For example:
 
-    ```swift
-    func doWork() throws -> Result {
-        var result: Result? = nil
-        var error: ErrorProtocol? = nil
-        autoreleasepool {
-            do {
-                ... actual computation which hopefully assigns to result but might not ...
-            } catch let e {
-                error = e
-            }
+```swift
+func doWork() throws -> Result {
+    var result: Result? = nil
+    var error: ErrorProtocol? = nil
+    autoreleasepool {
+        do {
+            ... actual computation which hopefully assigns to result but might not ...
+        } catch let e {
+            error = e
         }
-        guard let result = result else {
-            throw error!
-        }
-        return result!
     }
-    ```
+    guard let result = result else {
+        throw error!
+    }
+    return result!
+}
+```
 
 ## Proposed solution
 
 I'd like to propose altering the signature of the standard library
 `autoreleasepool` function to allow for a generic return type, as well as
 allowing a `throw` of an error:
 
-    public func autoreleasepool<Result>(@noescape body: () throws -> Result) rethrows -> Result
+```swift
+public func autoreleasepool<Result>(@noescape body: () throws -> Result) rethrows -> Result
+```
 
 The case above becomes much more clear and less error-prone since the compiler
 can enforce that exactly one of the error and result are used:
 
-    ```swift
-    func doWork() throws -> Result {
-        return try autoreleasepool {
-            ... actual computation which either returns or throws ...
-        }
+```swift
+func doWork() throws -> Result {
+    return try autoreleasepool {
+        ... actual computation which either returns or throws ...
     }
-    ```
+}
+```
 
 As an aside, since this proposes changing the signature already, I would like
 to further propose changing the argument label from `code` to `body`. This seems
@@ -76,15 +78,15 @@ but isn't central to this proposal.
 
 The updated standard library function would read:
 
-    ```swift
-    public func autoreleasepool<Result>(@noescape body: () throws -> Result) rethrows -> Result {
-        let pool = __pushAutoreleasePool()
-        defer {
-            __popAutoreleasePool(pool)
-        }
-        return try body()
+```swift
+public func autoreleasepool<Result>(@noescape body: () throws -> Result) rethrows -> Result {
+    let pool = __pushAutoreleasePool()
+    defer {
+        __popAutoreleasePool(pool)
     }
-    ```
+    return try body()
+}
+```
 
 ## Impact on existing code
 
@@ -99,26 +101,26 @@ return type would be better.
 I also explored whether third-party code could wrap `autoreleasepool` themselves
 with something like:
 
-    ```swift
-    func autoreleasepool_generic<ResultType>(@noescape code: Void throws -> ResultType) rethrows -> ResultType {
-        var result:ResultType?
-        var error:ErrorProtocol?
-
-        autoreleasepool {
-            do {
-                result = try code()
-            } catch let e {
-                error = e
-            }
-        }
-  
-        if let result = result {
-            return result
+```swift
+func autoreleasepool_generic<ResultType>(@noescape code: Void throws -> ResultType) rethrows -> ResultType {
+    var result:ResultType?
+    var error:ErrorProtocol?
+
+    autoreleasepool {
+        do {
+            result = try code()
+        } catch let e {
+            error = e
         }
-  
-        throw error! // Doesn't compile.
     }
-    ```
+
+    if let result = result {
+        return result
+    }
+
+    throw error! // Doesn't compile.
+}
+```
 
 but this doesn't compile, since in a function with `rethrows`, only the call to
 the passed in function that is marked as `throws` is allowed to throw.