Iterate on editorial feedback

Author: amartini51

TSPL.docc/LanguageGuide/ErrorHandling.md

@@ -762,7 +762,9 @@ To specify that a function throws only `StatisticsError` values as its errors,
 you write `throws(StatisticsError)` instead of only `throws`
 when declaring the function.
 This syntax is also called *typed throws*
-because you write the error type after `throws` --- for example:
+because you write the error type after `throws` in the declaration.
+For example,
+the function below throws `StatisticsError` values as its errors.
 
 ```swift
 func summarize(_ ratings: [Int]) throws(StatisticsError) {
@@ -808,7 +810,7 @@ func someThrowingFunction() -> throws {
 
 The code above doesn't specify an error type for `someThrowingFunction()`,
 so it throws `any Error`.
-You could also write the error type explicitly as `throws(any Error)` ---
+You could also write the error type explicitly as `throws(any Error)`;
 the code below is equivalent to the code above:
 
 ```swift

TSPL.docc/ReferenceManual/Declarations.md

@@ -1478,7 +1478,7 @@ Calls to a throwing function or method must be wrapped in a `try` or `try!` expr
 
 A function's type includes whether it can throw an error
 and what type of error it throws.
-This means, for example, you can use a nonthrowing function
+This subtype relationship means, for example, you can use a nonthrowing function
 in a context where a throwing one is expected.
 For more information about the type of a throwing function,
 see <doc:Types#Function-Type>.

TSPL.docc/ReferenceManual/Statements.md

@@ -898,21 +898,21 @@ a concrete type that conforms to the `Error` protocol,
 an opaque type that conforms to the `Error` protocol,
 or the boxed protocol type `any Error`.
 If the `do` statement doesn't specify the type of error it throws,
-the error type is inferred as follows:
+Swift infers the error type as follows:
 
 - If every `throws` statement and `try` expression in the `do` code block
   is nested inside of an exhaustive error-handling mechanism,
-  then the `do` statement is inferred as nonthrowing.
+  then Swift infers that the `do` statement is nonthrowing.
 
 - If the `do` code block contains code that throws
   errors of only a single type
   outside of exhaustive error handling,
-  then the `do` statement is inferred as throwing that concrete error type.
+  then Swift infers that the `do` statement throws that concrete error type.
 
 - If the `do` code block contains code that throws
   errors of more than a single type
   outside of exhaustive error handling,
-  then the `do` statement is inferred as throwing `any Error`.
+  then Swift infers that the `do` statement throws `any Error`.
 
 For more information about working with errors that have explicit types,
 see <doc:ErrorHandling#Specifying-a-Concrete-Error-Type>.