fix: fix link error, translation error and format error

Author: Intro1997

swift-6.docc/LanguageGuide/Concurrency.md

@@ -637,7 +637,8 @@ let handle = Task {
 let result = await handle.value
 ```
 
-要了解更多有关如何管理分离任务的信息，请查看 [`Task`](https://developer.apple.com/documentation/swift/task).
+要了解更多有关如何管理分离任务的信息，请查看 [`Task`](https://developer.apple.com/documentation/swift/task)。
+
 [`Task.init(priority:operation:)`]: https://developer.apple.com/documentation/swift/task/init(priority:operation:)-7f0zv
 [`Task.detached(priority:operation:)`]: https://developer.apple.com/documentation/swift/task/detached(priority:operation:)-d24l
 
@@ -652,7 +653,7 @@ let result = await handle.value
 
 你可以使用任务来将自己的程序分割为相互独立、并行的片段。任务之间时相互隔离的，这样他们才能安全地同时运行。但有时候，你需要在任务之前共享信息。此时，你就可以使用 actors 来安全地在并行代码之间共享这些信息。
 
-就和类一样，actor 也是应用类型，所以在  <doc:ClassesAndStructures#类是引用类型> 一文中有关引用类型和值类型的对比，同时适用于类和 actor。与类不同的是，actor 在同一时刻只允许一项任务访问其可变状态，这样多个任务同时与 actor 交互时才不会产生安全性问题。举个例子，下面是一个用于记录温度的 actor：
+就和类一样，actor 也是引用类型，所以在  <doc:ClassesAndStructures#类是引用类型> 一文中有关引用类型和值类型的对比，同时适用于类和 actor。与类不同的是，actor 在同一时刻只允许一项任务访问其可变状态，这样多个任务同时与 actor 交互时才不会产生安全性问题。举个例子，下面是一个用于记录温度的 actor：
 
 ```swift
 actor TemperatureLogger {

swift-6.docc/LanguageGuide/Extensions.md

@@ -109,7 +109,7 @@ extension SomeType: SomeProtocol, AnotherProtocol {
 
 这种遵循协议的方式在 <doc:Protocols#在扩展里添加协议遵循> 中有描述。
 
-扩展可以使用在现有泛型类型上，就像 <doc:Generics#Extending-a-Generic-Type> 中描述的一样。你还可以使用扩展给泛型类型有条件地添加功能，就像 <doc:Generics#Extensions-with-a-Generic-Where-Clause> 中描述的一样。
+扩展可以使用在现有泛型类型上，就像 <doc:Generics#泛型扩展> 中描述的一样。你还可以使用扩展给泛型类型有条件地添加功能，就像 <doc:Generics#具有泛型-Where-子句的扩展> 中描述的一样。
 
 > 注意: 对一个现有的类型，如果你定义了一个扩展来添加新的功能，那么这个类型的所有实例都可以使用这个新功能，包括那些在扩展定义之前就存在的实例。
 

swift-6.docc/LanguageGuide/Initialization.md

@@ -5,7 +5,7 @@
 
 你可以通过定义*构造器*来实现这个构造过程，它就像是用来创建特定类型新实例的特殊方法。与Objective-C构造器不同，Swift构造器没有返回值，它们的主要作用是确保类型的新实例在首次使用前被正确构造。
 
-类的实例可以通过实现*析构器*来执行它释放之前自定义的清理工作。想了解析构器的更多内容，请参见 <doc:析构过程>.
+类的实例可以通过实现*析构器*来执行它释放之前自定义的清理工作。想了解析构器的更多内容，请参见 <doc:Deinitialization>.
 
 ## 存储属性的初始赋值
 
@@ -542,7 +542,7 @@ print(zeroByZero.width, zeroByZero.height)
 构造器可以调用其他构造器来完成实例的部分构造过程。这个过程被称为*构造器代理*，它避免了在多个构造器中重复代码。
 
 构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。
-然而，类不一样，它可以继承自其他类（请参考<doc:继承>）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节<doc:类的继承和构造过程>中介绍。
+然而，类不一样，它可以继承自其他类（请参考<doc:Inheritance>）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节<doc:类的继承和构造过程>中介绍。
 
 对于值类型，你可以使用 `self.init` 在自定义的构造器中引用相同值类型的构造器。并且，你只能在构造器内部调用 `self.init` 。
 
@@ -871,7 +871,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
   ```
 -->
 
-相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文<doc:类的构造器代理规则>有所描述）。
+相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文<doc:类类型的构造器代理>有所描述）。
 因此，严格意义上来讲，你的子类并未对一个父类构造器提供重写。最后的结果就是，你在子类中“重写”一个父类便利构造器时，不需要加 `override` 修饰符。
 
 <!--
@@ -1912,7 +1912,7 @@ class AutomaticallyNamedDocument: Document {
   ```
 -->
 
-`AutomaticallyNamedDocument` 用一个不可失败构造器 `init?(name:)` 重写了父类的可失败构造器。因为子类用另一种方式处理了空字符串的情况，所以不再需要一个可失败构造器，因此子类用一个不可失败构造器代替了父类的可失败构造器。
+`AutomaticallyNamedDocument` 用一个不可失败构造器 `init(name:)` 重写了父类的可失败构造器。因为子类用另一种方式处理了空字符串的情况，所以不再需要一个可失败构造器，因此子类用一个不可失败构造器代替了父类的可失败构造器。
 
 你可以在子类的不可失败构造器中使用强制解包来调用父类的可失败构造器。比如，下面的 `UntitledDocument` 子类总是被命名为 `"[Untitled]"` 并且在初始化阶段使用父类的可失败构造器 `init(name:)` 。
 

swift-6.docc/LanguageGuide/NestedTypes.md

@@ -2,7 +2,7 @@
 
 在另一个类型的作用域内定义类型。
 
-枚举常被创建以支持特定类或结构的功能。同样的，为了在更复杂类型的上下文中使用而定义纯工具性结构，以及通常与特定类型结合使用的协议，也显得十分便利。为了实现这一点，Swift 允许你定义 *嵌套类型*，即在支持的类型定义中嵌套枚举、结构和协议等辅助类型。
+枚举常被创建以支持特定类或结构的功能。同样的，为了在更复杂类型的上下文中使用而定义的纯工具性结构体，以及通常与特定类型结合使用的协议，也显得十分便利。为了实现这一点，Swift 允许你定义 *嵌套类型*，即在支持的类型定义中嵌套枚举、结构和协议等辅助类型。
 
 要在一个类型中嵌套另一个类型，只需将其定义写在外部类型的大括号内。类型可以根据需要嵌套到任意层次。
 
@@ -112,7 +112,7 @@ struct BlackjackCard {
 
 `BlackjackCard` 结构本身有两个属性 —— `rank` 和 `suit`。它还定义了一个名为 `description` 的计算属性，该属性使用 `rank` 和 `suit` 中存储的值来构建牌的名称和数值的描述。`description` 属性使用可选绑定来检查是否存在第二个值，如果有，则为第二个值插入额外的描述信息。
 
-由于 `BlackjackCard` 是一个没有自定义初始化器的结构体，它具有一个隐式的成员逐一初始化器，正如在 [[doc:Initialization#Memberwise-Initializers-for-Structure-Types](doc:Initialization#Memberwise-Initializers-for-Structure-Types)]中所描述的那样。你可以使用这个初始化器来初始化一个名为 `theAceOfSpades` 的新常量：
+由于 `BlackjackCard` 是一个没有自定义初始化器的结构体，它具有一个隐式的成员逐一初始化器，正如在 <doc:Initialization#结构体类型的成员逐一构造器> 中所描述的那样。你可以使用这个初始化器来初始化一个名为 `theAceOfSpades` 的新常量：
 
 ```swift
 let theAceOfSpades = BlackjackCard(rank: .ace, suit: .spades)

swift-6.docc/ReferenceManual/Attributes.md

@@ -13,7 +13,7 @@
 
 有些声明特性接受参数，这些参数指定有关特性的更多信息以及它如何适用于特定声明。这些*特性参数*被括号括起来，其格式由它们所属的特性定义。
 
-附加宏和属性包装器也使用特性语法。有关宏如何展开的信息，参见 <doc:Expressions#宏展开表达式>。有关属性包装器的信息，参见 <doc:Attributes#属性包装器>。
+附加宏和属性包装器也使用特性语法。有关宏如何展开的信息，参见 <doc:Expressions#宏扩展表达式>。有关属性包装器的信息，参见 <doc:Attributes#属性包装器>。
 
 ## 声明特性
 
@@ -999,7 +999,7 @@ class ExampleClass: NSObject {
 
 来自 Objective-C 的声明在导入时始终被视为带有 `preconcurrency` 特性标记。
 
-### propertyWrapper
+### 属性包装器
 
 将此特性应用于类、结构体或枚举声明，以将该类型用作属性包装器。当你将此特性应用于某个类型时，你会创建一个与该类型同名的自定义特性。将该新特性应用于类、结构体或枚举的属性，以通过包装器类型的实例来包装对该属性的访问；将特性应用于局部存储变量声明，以相同方式包装对变量的访问。计算变量、全局变量和常量不能使用属性包装器。
 

swift-6.docc/ReferenceManual/Declarations.md

@@ -2,7 +2,7 @@
 
 引入类型、运算符、变量以及其他名称和构造。
 
-*声明*将在程序中引入一个新的名称或构造例如，你使用声明来引入函数和方法，引入变量和常量，以及定义枚举、结构体、类和协议类型。你还可以使用声明来扩展现有具名类型的行为，并将其他地方声明的符号引入到你的程序中。
+*声明*将在程序中引入一个新的名称或构造。例如，你使用声明来引入函数和方法，引入变量和常量，以及定义枚举、结构体、类和协议类型。你还可以使用声明来扩展现有具名类型的行为，并将其他地方声明的符号引入到你的程序中。
 
 在 Swift 中，大多数声明也是定义，因为它们在声明的同时被实现或初始化。但由于协议不实现它的成员，所以协议成员在此仅仅是声明。为了方便起见，而且这种区别在 Swift 中没那么重要，所以术语*声明*涵盖了声明和定义两种含义。
 
@@ -220,7 +220,7 @@ var <#variable name#>: <#type#> {
 
 getter 用于读取值，setter 用于写入值。setter 子句是可选的，当只需要 getter 时，可以省略两个子句，直接返回请求的值，参见 <doc:Properties#只读计算属性>。但如果提供了 setter 子句，则必须同时提供 getter 子句。
 
-*setter 名称*和括号是可选的。如果你提供了 setter 名称，它将用作 setter 参数的名称。如果你不提供 setter 名称，setter 的默认参数名称是 `newValue`，参见 <doc:Properties#简写Setter声明>。
+*setter 名称*和括号是可选的。如果你提供了 setter 名称，它将用作 setter 参数的名称。如果你不提供 setter 名称，setter 的默认参数名称是 `newValue`，参见 <doc:Properties#简化-Setter-声明>。
 
 与存储的具名值和存储的变量属性不同，计算的具名值或计算属性的值并不会存储在内存中。
 
@@ -1114,7 +1114,7 @@ func <#function name#>(<#parameters#>) throws(<#error type#>) -> <#return type#>
 
 调用抛出函数或方法的必须被包裹在一个 `try` 或 `try!` 表达式中（即，在 `try` 或 `try!` 操作符的作用域内）。
 
-函数的类型包括：它是否会抛出错误，以及它抛出的错误类型。非抛出函数是抛出函数的子类型。所以，可以在使用抛出函数的地方使用非抛出函数。有关抛出错误函数类型的更多信息，请参阅 <doc:Types#Function-Type>。有关处理具有显式类型的错误的示例，请参阅 <doc:ErrorHandling#Specifying-the-Error-Type>。
+函数的类型包括：它是否会抛出错误，以及它抛出的错误类型。非抛出函数是抛出函数的子类型。所以，可以在使用抛出函数的地方使用非抛出函数。有关抛出错误函数类型的更多信息，请参阅 <doc:Types#函数类型>。有关处理具有显式类型的错误的示例，请参阅 <doc:ErrorHandling#指定错误类型>。
 
 你不能仅根据函数是否会抛出错误来重载一个函数。不过，你可以根据函数的*参数*是否会抛出错误来重载函数。
 

swift-6.docc/ReferenceManual/Types.md

@@ -22,7 +22,21 @@
 本章讨论了 Swift 语言本身定义的类型，并描述了 Swift 的类型推断行为。
 
 > 类型的语法:
-> > *type* → *function-type* \ > *type* → *array-type* \ > *type* → *dictionary-type* \ > *type* → *type-identifier* \ > *type* → *tuple-type* \ > *type* → *optional-type* \ > *type* → *implicitly-unwrapped-optional-type* \ > *type* → *protocol-composition-type* \ > *type* → *opaque-type* \ > *type* → *boxed-protocol-type* \ > *type* → *metatype-type* \ > *type* → *any-type* \ > *type* → *self-type* \ > *type* → **`(`** *type* **`)`**
+>
+> *type* → *function-type* \
+> *type* → *array-type* \
+> *type* → *dictionary-type* \
+> *type* → *type-identifier* \
+> *type* → *tuple-type* \
+> *type* → *optional-type* \
+> *type* → *implicitly-unwrapped-optional-type* \
+> *type* → *protocol-composition-type* \
+> *type* → *opaque-type* \
+> *type* → *boxed-protocol-type* \
+> *type* → *metatype-type* \
+> *type* → *any-type* \
+> *type* → *self-type* \
+> *type* → **`(`** *type* **`)`**
 
 ## 类型注解
 
@@ -40,7 +54,8 @@ func someFunction(a: Int) { /* ... */ }
 类型注解可以在类型之前包含一个可选的类型属性列表。
 
 > 类型注解的语法:
-> > *type-annotation* → **`:`** *attributes*_?_ *type*
+>
+> *type-annotation* → **`:`** *attributes*_?_ *type*
 
 ## 类型标识符
 
@@ -75,6 +90,8 @@ someTuple = (left: 5, right: 5)  // 错误: 名称不匹配
 
 除了 Void 是空元组类型 () 的类型别名外，所有元组类型都包含两个或更多类型。
 
+## 函数类型
+
 函数类型表示函数、方法或闭包的类型，由一个参数类型和返回类型组成，用箭头(->)分隔:
 
 ```swift
@@ -162,13 +179,17 @@ func takesTwoFunctions(first: (() -> Void) -> Void, second: (() -> Void) -> Void
 如果你需要避免这个限制，可以将其中一个参数标记为逃逸的，或者使用 `withoutActuallyEscaping(_:do:)` 函数临时将其中一个非逃逸函数参数转换为逃逸函数。有关避免内存访问冲突的信息，请参阅 <doc:MemorySafety>。
 
 > 函数类型的语法:
-> > *function-type* → *attributes*_?_ *function-type-argument-clause* **`async`**_?_ *throws-clause*_?_ **`->`** *type*
-> > *function-type-argument-clause* → **`(`** **`)`** \
+>
+> *function-type* → *attributes*_?_ *function-type-argument-clause* **`async`**_?_ *throws-clause*_?_ **`->`** *type*
+>
+> *function-type-argument-clause* → **`(`** **`)`** \
 > *function-type-argument-clause* → **`(`** *function-type-argument-list* **`...`**_?_ **`)`**
-> > *function-type-argument-list* → *function-type-argument* | *function-type-argument* **`,`** *function-type-argument-list* \
+>
+> *function-type-argument-list* → *function-type-argument* | *function-type-argument* **`,`** *function-type-argument-list* \
 > *function-type-argument* → *attributes*_?_ *parameter-modifier*_?_ *type* | *argument-label* *type-annotation* \
 > *argument-label* → *identifier*
-> > *throws-clause* → **`throws`** | **`throws`** **`(`** *type* **`)`**
+>
+> *throws-clause* → **`throws`** | **`throws`** **`(`** *type* **`)`**
 
 func polymorphicF<T>(a: Int) -> T { return a } 是一个泛型函数，可以返回任何类型的值。而 monomorphicF(a: Int) -> Int { return a } 是一个单态函数，只能返回 Int 类型的值。
 
@@ -208,7 +229,8 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
 有关 Swift 标准库 `Array` 类型的详细讨论，请参阅 <doc:CollectionTypes#数组>。
 
 > 数组类型的语法:
-> > *array-type* → **`[`** *type* **`]`**
+>
+> *array-type* → **`[`** *type* **`]`**
 
 ## 字典类型
 
@@ -236,9 +258,8 @@ let someDictionary: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]
 有关 Swift 标准库 `Dictionary` 类型的详细讨论，请参阅 <doc:CollectionTypes#字典>。
 
 > 字典类型的语法:
-> > *dictionary-type* → **`[`** *type* **`:`** *type* **`]`**
-
-## 可选类型
+>
+> *dictionary-type* → **`[`** *type* **`:`** *type* **`]`**
 
 ## 可选类型
 
@@ -267,7 +288,8 @@ optionalInteger! // 42
 有关更多信息和示例说明如何使用可选类型，请参阅 <doc:TheBasics#可选项>。
 
 > 可选类型的语法:
-> > *optional-type* → *type* **`?`**
+>
+> *optional-type* → *type* **`?`**
 
 ## 隐式解包可选类型
 
@@ -296,7 +318,7 @@ let implicitlyUnwrappedArray: [Int]!                  // 正确
 
 使用可选链来有条件地对隐式解包可选表达式执行操作。如果值为 `nil`，则不执行任何操作，因此也不会产生运行时错误。
 
-有关隐式解包可选类型的更多信息，请参阅 <doc:TheBasics#隐式解析可选类型>。
+有关隐式解包可选类型的更多信息，请参阅 <doc:TheBasics#隐式解包可选>。
 
 为参数编写不透明类型是使用泛型类型的一种语法糖，并且没有为泛型类型参数指定名称。这个隐式的泛型类型参数有一个约束，要求它遵循不透明类型中指定的协议。如果你编写了多个不透明类型，每一个都会创建自己的泛型类型参数。例如，下面的声明是等价的：
 
@@ -417,7 +439,8 @@ let anotherInstance = metatype.init(string: "some string")
   ```swifttest -> class AnotherSubClass: SomeBaseClass { let string: String required init(string: String) { self.string = string } override class func printClassName() { print("AnotherSubClass") } } -> let metatype: AnotherSubClass.Type = AnotherSubClass.self -> let anotherInstance = metatype.init(string: "some string") ``` -->
 
 > 元类型语法:
-> > *metatype-type* → *type* **`.`** **`Type`** | *type* **`.`** **`Protocol`**  
+>
+> *metatype-type* → *type* **`.`** **`Type`** | *type* **`.`** **`Protocol`**  
 
 ## Any 类型
 
@@ -461,7 +484,8 @@ if let first = mixed.first as? String {
 有关更多信息，请参阅 <doc:Protocols#类专属协议> 和 [`AnyObject`](https://developer.apple.com/documentation/swift/anyobject)。
 
 > Any 类型语法:
-> > *any-type* → **`Any`**
+>
+> *any-type* → **`Any`**
 
 ## Self 类型  
 
@@ -500,7 +524,10 @@ if let first = mixed.first as? String {
 `Self` 类型指的是与 Swift 标准库中的 `type(of:)` 函数相同的类型。写 `Self.someStaticMember` 来访问当前类型的成员与写 `type(of: self).someStaticMember` 是一样的。
 
 > Self 类型的语法:
-> > *self-type* → **`Self`**
+> 
+> *self-type* → **`Self`**
+
+## 类型继承子句
 
 *类型继承子句* 用于指定命名类型继承自哪个类以及符合哪些协议。类型继承子句以冒号 (:) 开头，后跟一系列类型标识符。
 
@@ -511,8 +538,11 @@ if let first = mixed.first as? String {
 对于为枚举案例分配原始值的枚举定义，类型继承子句可以是指定这些原始值类型的单个命名类型。有关使用类型继承子句指定其原始值类型的枚举定义示例，请参阅 <doc:Enumerations#原始值>。
 
 > 类型继承子句的语法:
-> > *type-inheritance-clause* → **`:`** *type-inheritance-list* 
-> > *type-inheritance-list* → *attributes*_?_ *type-identifier* | *attributes*_?_ *type-identifier* **`,`** *type-inheritance-list*
+>
+> *type-inheritance-clause* → **`:`** *type-inheritance-list* 
+> *type-inheritance-list* → *attributes*_?_ *type-identifier* | *attributes*_?_ *type-identifier* **`,`** *type-inheritance-list*
+
+## 类型推断
 
 Swift 广泛使用 *类型推断*，允许你在代码中省略许多变量和表达式的类型或部分类型。