Minor fixes (#70)

Author: amartini51

.gitattributes

@@ -1,2 +1,3 @@
 *.md linguist-detectable=true
 *.md linguist-documentation=false
+*.md diff=markdown

Sources/TSPL/TSPL.docc/LanguageGuide/Initialization.md

@@ -925,9 +925,14 @@ convenience init(<#parameters#>) {
 To simplify the relationships between designated and convenience initializers,
 Swift applies the following three rules for delegation calls between initializers:
 
-- term **Rule 1**: A designated initializer must call a designated initializer from its immediate superclass.
-- term **Rule 2**: A convenience initializer must call another initializer from the *same* class.
-- term **Rule 3**: A convenience initializer must ultimately call a designated initializer.
+- term **Rule 1**:
+  A designated initializer must call a designated initializer from its immediate superclass.
+
+- term **Rule 2**:
+  A convenience initializer must call another initializer from the *same* class.
+
+- term **Rule 3**:
+  A convenience initializer must ultimately call a designated initializer.
 
 A simple way to remember this is:
 
@@ -990,28 +995,34 @@ by another initializer unexpectedly.
 Swift's compiler performs four helpful safety-checks to make sure that
 two-phase initialization is completed without error:
 
-- term **Safety check 1**: A designated initializer must ensure that all of the properties introduced by its class
-are initialized before it delegates up to a superclass initializer.
+- term **Safety check 1**:
+  A designated initializer must ensure that all of the properties introduced by its class
+  are initialized before it delegates up to a superclass initializer.
 
 As mentioned above,
 the memory for an object is only considered fully initialized
 once the initial state of all of its stored properties is known.
 In order for this rule to be satisfied, a designated initializer must make sure that
 all of its own properties are initialized before it hands off up the chain.
 
-- term **Safety check 2**: A designated initializer must delegate up to a superclass initializer
-before assigning a value to an inherited property.
-If it doesn't, the new value the designated initializer assigns
-will be overwritten by the superclass as part of its own initialization.
-- term **Safety check 3**: A convenience initializer must delegate to another initializer
-before assigning a value to *any* property
-(including properties defined by the same class).
-If it doesn't, the new value the convenience initializer assigns
-will be overwritten by its own class's designated initializer.
-- term **Safety check 4**: An initializer can't call any instance methods,
-read the values of any instance properties,
-or refer to `self` as a value
-until after the first phase of initialization is complete.
+- term **Safety check 2**:
+  A designated initializer must delegate up to a superclass initializer
+  before assigning a value to an inherited property.
+  If it doesn't, the new value the designated initializer assigns
+  will be overwritten by the superclass as part of its own initialization.
+
+- term **Safety check 3**:
+  A convenience initializer must delegate to another initializer
+  before assigning a value to *any* property
+  (including properties defined by the same class).
+  If it doesn't, the new value the convenience initializer assigns
+  will be overwritten by its own class's designated initializer.
+
+- term **Safety check 4**:
+  An initializer can't call any instance methods,
+  read the values of any instance properties,
+  or refer to `self` as a value
+  until after the first phase of initialization is complete.
 
 The class instance isn't fully valid until the first phase ends.
 Properties can only be accessed, and methods can only be called,
@@ -1431,13 +1442,16 @@ and can inherit your superclass initializers with minimal effort whenever it's s
 Assuming that you provide default values for any new properties you introduce in a subclass,
 the following two rules apply:
 
-- term **Rule 1**: If your subclass doesn't define any designated initializers,
-it automatically inherits all of its superclass designated initializers.
-- term **Rule 2**: If your subclass provides an implementation of
-*all* of its superclass designated initializers ---
-either by inheriting them as per rule 1,
-or by providing a custom implementation as part of its definition ---
-then it automatically inherits all of the superclass convenience initializers.
+- term **Rule 1**:
+  If your subclass doesn't define any designated initializers,
+  it automatically inherits all of its superclass designated initializers.
+
+- term **Rule 2**:
+  If your subclass provides an implementation of
+  *all* of its superclass designated initializers ---
+  either by inheriting them as per rule 1,
+  or by providing a custom implementation as part of its definition ---
+  then it automatically inherits all of the superclass convenience initializers.
 
 These rules apply even if your subclass adds further convenience initializers.
 

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

@@ -1364,42 +1364,49 @@ they default to being the same as `Component`.
 
 The result-building methods are as follows:
 
-<!--
-  start of term/defn list
--->
-
-- term `static func buildBlock(_ components: Component...) -> Component`: Combines an array of partial results into a single partial result.
-A result builder must implement this method.
-- term `static func buildOptional(_ component: Component?) -> Component`: Builds a partial result from a partial result that can be `nil`.
-Implement this method to support `if` statements
-that don’t include an `else` clause.
-- term `static func buildEither(first: Component) -> Component`: Builds a partial result whose value varies depending on some condition.
-Implement both this method and `buildEither(second:)`
-to support `switch` statements
-and `if` statements that include an `else` clause.
-- term `static func buildEither(second: Component) -> Component`: Builds a partial result whose value varies depending on some condition.
-Implement both this method and `buildEither(first:)`
-to support `switch` statements
-and `if` statements that include an `else` clause.
-- term `static func buildArray(_ components: [Component]) -> Component`: Builds a partial result from an array of partial results.
-Implement this method to support `for` loops.
-- term `static func buildExpression(_ expression: Expression) -> Component`: Builds a partial result from an expression.
-You can implement this method to perform preprocessing ---
-for example, converting expressions to an internal type ---
-or to provide additional information for type inference at use sites.
-- term `static func buildFinalResult(_ component: Component) -> FinalResult`: Builds a final result from a partial result.
-You can implement this method as part of a result builder
-that uses a different type for partial and final results,
-or to perform other postprocessing on a result before returning it.
-- term `static func buildLimitedAvailability(_ component: Component) -> Component`: Builds a partial result that propagates or erases type information
-outside a compiler-control statement
-that performs an availability check.
-You can use this to erase type information
-that varies between the conditional branches.
-
-<!--
-  end of term/defn list
--->
+- term `static func buildBlock(_ components: Component...) -> Component`:
+  Combines an array of partial results into a single partial result.
+  A result builder must implement this method.
+
+- term `static func buildOptional(_ component: Component?) -> Component`:
+  Builds a partial result from a partial result that can be `nil`.
+  Implement this method to support `if` statements
+  that don’t include an `else` clause.
+
+- term `static func buildEither(first: Component) -> Component`:
+  Builds a partial result whose value varies depending on some condition.
+  Implement both this method and `buildEither(second:)`
+  to support `switch` statements
+  and `if` statements that include an `else` clause.
+
+- term `static func buildEither(second: Component) -> Component`:
+  Builds a partial result whose value varies depending on some condition.
+  Implement both this method and `buildEither(first:)`
+  to support `switch` statements
+  and `if` statements that include an `else` clause.
+
+- term `static func buildArray(_ components: [Component]) -> Component`:
+  Builds a partial result from an array of partial results.
+  Implement this method to support `for` loops.
+
+- term `static func buildExpression(_ expression: Expression) -> Component`:
+  Builds a partial result from an expression.
+  You can implement this method to perform preprocessing ---
+  for example, converting expressions to an internal type ---
+  or to provide additional information for type inference at use sites.
+
+- term `static func buildFinalResult(_ component: Component) -> FinalResult`:
+  Builds a final result from a partial result.
+  You can implement this method as part of a result builder
+  that uses a different type for partial and final results,
+  or to perform other postprocessing on a result before returning it.
+
+- term `static func buildLimitedAvailability(_ component: Component) -> Component`:
+  Builds a partial result that propagates or erases type information
+  outside a compiler-control statement
+  that performs an availability check.
+  You can use this to erase type information
+  that varies between the conditional branches.
 
 For example, the code below defines a simple result builder
 that builds an array of integers.