Restore paragraph breaks that were lost lost during the RST export (#79)

Fixes rdar://102991635

Author: amartini51

Sources/TSPL/TSPL.docc/LanguageGuide/AutomaticReferenceCounting.md

@@ -601,7 +601,9 @@ and ARC never sets an unowned reference's value to `nil`.
 -->
 
 > Important: Use an unowned reference only when you are sure that
-> the reference *always* refers to an instance that hasn't been deallocated.If you try to access the value of an unowned reference
+> the reference *always* refers to an instance that hasn't been deallocated.
+>
+> If you try to access the value of an unowned reference
 > after that instance has been deallocated,
 > you'll get a runtime error.
 
@@ -768,7 +770,9 @@ after the `john` variable is set to `nil`.
 > you need to disable runtime safety checks ---
 > for example, for performance reasons.
 > As with all unsafe operations,
-> you take on the responsibility for checking that code for safety.You indicate an unsafe unowned reference by writing `unowned(unsafe)`.
+> you take on the responsibility for checking that code for safety.
+>
+> You indicate an unsafe unowned reference by writing `unowned(unsafe)`.
 > If you try to access an unsafe unowned reference
 > after the instance that it refers to is deallocated,
 > your program will try to access the memory location
@@ -909,7 +913,9 @@ that other courses might have.
 > Note: The underlying type of an optional value is `Optional`,
 > which is an enumeration in the Swift standard library.
 > However, optionals are an exception to the rule that
-> value types can't be marked with `unowned`.The optional that wraps the class
+> value types can't be marked with `unowned`.
+>
+> The optional that wraps the class
 > doesn't use reference counting,
 > so you don't need to maintain a strong reference to the optional.
 

Sources/TSPL/TSPL.docc/LanguageGuide/Closures.md

@@ -731,7 +731,9 @@ the next time the `incrementer` function is called.
 > Note: As an optimization,
 > Swift may instead capture and store a *copy* of a value
 > if that value isn't mutated by a closure,
-> and if the value isn't mutated after the closure is created.Swift also handles all memory management involved in disposing of
+> and if the value isn't mutated after the closure is created.
+>
+> Swift also handles all memory management involved in disposing of
 > variables when they're no longer needed.
 
 Here's an example of `makeIncrementer` in action:

Sources/TSPL/TSPL.docc/LanguageGuide/CollectionTypes.md

@@ -54,7 +54,9 @@ and its size and contents can't be changed.
 An *array* stores values of the same type in an ordered list.
 The same value can appear in an array multiple times at different positions.
 
-> Note: Swift's `Array` type is bridged to Foundation's `NSArray` class.For more information about using `Array` with Foundation and Cocoa,
+> Note: Swift's `Array` type is bridged to Foundation's `NSArray` class.
+>
+> For more information about using `Array` with Foundation and Cocoa,
 > see [Bridging Between Array and NSArray](https://developer.apple.com/documentation/swift/array#2846730).
 
 ### Array Type Shorthand Syntax
@@ -580,7 +582,9 @@ in a collection with no defined ordering.
 You can use a set instead of an array when the order of items isn't important,
 or when you need to ensure that an item only appears once.
 
-> Note: Swift's `Set` type is bridged to Foundation's `NSSet` class.For more information about using `Set` with Foundation and Cocoa,
+> Note: Swift's `Set` type is bridged to Foundation's `NSSet` class.
+>
+> For more information about using `Set` with Foundation and Cocoa,
 > see [Bridging Between Set and NSSet](https://developer.apple.com/documentation/swift/set#2845530).
 
 <!--
@@ -1027,7 +1031,9 @@ You use a dictionary when you need to look up values based on their identifier,
 in much the same way that a real-world dictionary is used to look up
 the definition for a particular word.
 
-> Note: Swift's `Dictionary` type is bridged to Foundation's `NSDictionary` class.For more information about using `Dictionary` with Foundation and Cocoa,
+> Note: Swift's `Dictionary` type is bridged to Foundation's `NSDictionary` class.
+>
+> For more information about using `Dictionary` with Foundation and Cocoa,
 > see [Bridging Between Dictionary and NSDictionary](https://developer.apple.com/documentation/swift/dictionary#2846239).
 
 ### Dictionary Type Shorthand Syntax

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

@@ -1732,9 +1732,11 @@ and to determine whether the move is allowed:
 
 > Note: If the `break` statement above didn't use the `gameLoop` label,
 > it would break out of the `switch` statement, not the `while` statement.
-> Using the `gameLoop` label makes it clear which control statement should be terminated.It isn't strictly necessary to use the `gameLoop` label
+> Using the `gameLoop` label makes it clear which control statement should be terminated.
+>
+> It isn't strictly necessary to use the `gameLoop` label
 > when calling `continue gameLoop` to jump to the next iteration of the loop.
-> there's only one loop in the game,
+> There's only one loop in the game,
 > and therefore no ambiguity as to which loop the `continue` statement will affect.
 > However, there's no harm in using the `gameLoop` label with the `continue` statement.
 > Doing so is consistent with the label's use alongside the `break` statement

Sources/TSPL/TSPL.docc/LanguageGuide/Inheritance.md

@@ -435,7 +435,9 @@ For more information on property observers, see <doc:Properties#Property-Observe
 > inherited constant stored properties or inherited read-only computed properties.
 > The value of these properties can't be set,
 > and so it isn't appropriate to provide a `willSet` or `didSet` implementation
-> as part of an override.Note also that you can't provide both
+> as part of an override.
+>
+> Note also that you can't provide both
 > an overriding setter and an overriding property observer for the same property.
 > If you want to observe changes to a property's value,
 > and you are already providing a custom setter for that property,

Sources/TSPL/TSPL.docc/LanguageGuide/MemorySafety.md

@@ -112,7 +112,9 @@ you have to determine what it was intended to do.
 > However,
 > the conflicting access discussed here can happen
 > on a single thread and
-> *doesn't* involve concurrent or multithreaded code.If you have conflicting access to memory
+> *doesn't* involve concurrent or multithreaded code.
+>
+> If you have conflicting access to memory
 > from within a single thread,
 > Swift guarantees that you'll get an error
 > at either compile time or runtime.

Sources/TSPL/TSPL.docc/LanguageGuide/Properties.md

@@ -737,7 +737,9 @@ the new value that you assign replaces the one that was just set.
 > are called when a property is set in a subclass initializer,
 > after the superclass initializer has been called.
 > They aren't called while a class is setting its own properties,
-> before the superclass initializer has been called.For more information about initializer delegation,
+> before the superclass initializer has been called.
+>
+> For more information about initializer delegation,
 > see <doc:Initialization#Initializer-Delegation-for-Value-Types>
 > and <doc:Initialization#Initializer-Delegation-for-Class-Types>.
 
@@ -1676,7 +1678,9 @@ and they're written in the same way as computed properties.
 > Note: Global constants and variables are always computed lazily,
 > in a similar manner to <doc:Properties#Lazy-Stored-Properties>.
 > Unlike lazy stored properties,
-> global constants and variables don't need to be marked with the `lazy` modifier.Local constants and variables are never computed lazily.
+> global constants and variables don't need to be marked with the `lazy` modifier.
+>
+> Local constants and variables are never computed lazily.
 
 You can apply a property wrapper to a local stored variable,
 but not to a global variable or a computed variable.
@@ -1763,7 +1767,9 @@ in the same way as computed instance properties.
 > Note: Unlike stored instance properties,
 > you must always give stored type properties a default value.
 > This is because the type itself doesn't have an initializer
-> that can assign a value to a stored type property at initialization time.Stored type properties are lazily initialized on their first access.
+> that can assign a value to a stored type property at initialization time.
+>
+> Stored type properties are lazily initialized on their first access.
 > They're guaranteed to be initialized only once,
 > even when accessed by multiple threads simultaneously,
 > and they don't need to be marked with the `lazy` modifier.

Sources/TSPL/TSPL.docc/LanguageGuide/StringsAndCharacters.md

@@ -29,7 +29,9 @@ and provides support for accessing those characters in various Unicode represent
 > Note: Swift's `String` type is bridged with Foundation's `NSString` class.
 > Foundation also extends `String` to expose methods defined by `NSString`.
 > This means, if you import Foundation,
-> you can access those `NSString` methods on `String` without casting.For more information about using `String` with Foundation and Cocoa,
+> you can access those `NSString` methods on `String` without casting.
+>
+> For more information about using `String` with Foundation and Cocoa,
 > see [Bridging Between String and NSString](https://developer.apple.com/documentation/swift/string#2919514).
 
 ## String Literals
@@ -958,7 +960,9 @@ print("the number of characters in \(word) is \(word.count)")
 > If you are working with particularly long string values,
 > be aware that the `count` property
 > must iterate over the Unicode scalars in the entire string
-> in order to determine the characters for that string.The count of the characters returned by the `count` property
+> in order to determine the characters for that string.
+>
+> The count of the characters returned by the `count` property
 > isn't always the same as the `length` property of
 > an `NSString` that contains the same characters.
 > The length of an `NSString` is based on

Sources/TSPL/TSPL.docc/LanguageGuide/TheBasics.md

@@ -2005,7 +2005,9 @@ by one of the switch's other cases.
 > The compiler assumes that preconditions are always true,
 > and it optimizes your code accordingly.
 > However, the `fatalError(_:file:line:)` function always halts execution,
-> regardless of optimization settings.You can use the `fatalError(_:file:line:)` function
+> regardless of optimization settings.
+>
+> You can use the `fatalError(_:file:line:)` function
 > during prototyping and early development
 > to create stubs for functionality that hasn't been implemented yet,
 > by writing `fatalError("Unimplemented")` as the stub implementation.

Sources/TSPL/TSPL.docc/ReferenceManual/Attributes.md

@@ -120,7 +120,9 @@ including important milestones.
   ```swift
   renamed: <#new name#>
   ```
-  The *new name* consists of a string literal.You can apply the `available` attribute
+  The *new name* consists of a string literal.
+
+  You can apply the `available` attribute
   with the `renamed` and `unavailable` arguments
   to a type alias declaration, as shown below,
   to indicate that the name of a declaration changed
@@ -1578,7 +1580,9 @@ into code that calls the static methods of the result builder type:
   because it's one of the types in the `DrawEither` generic type.
   This could cause your program to crash if `FutureText`
   isn't available at runtime,
-  even in the case where that type is explicitly not being used.To solve this problem,
+  even in the case where that type is explicitly not being used.
+
+  To solve this problem,
   implement a `buildLimitedAvailability(_:)` method
   to erase type information.
   For example, the code below builds an `AnyDrawable` value
@@ -1613,7 +1617,9 @@ into code that calls the static methods of the result builder type:
   the leaf nodes of a binary tree,
   and the statement becomes
   a nested call to the `buildEither` methods
-  following the path to that leaf node from the root node.For example, if you write a switch statement that has three cases,
+  following the path to that leaf node from the root node.
+
+  For example, if you write a switch statement that has three cases,
   the compiler uses a binary tree with three leaf nodes.
   Likewise,
   because the path from the root node to the second case is