# 《The Swift Programming Language》中文版

# The Swift Programming Language 中文版

- 序
- 1. 欢迎使用 Swift
  - 1.1. 关于 Swift
  - 1.2. Swift 初见
- 2. Swift 教程
  - 2.1. 基础部分
  - 2.2. 基本运算符
  - 2.3. 字符串和字符
  - 2.4. 集合类型
  - 2.5. 控制流
  - 2.6. 函数
  - 2.7. 闭包
  - 2.8. 枚举
  - 2.9. 类和结构体
  - 2.10. 属性
  - 2.11. 方法
  - 2.12. 下标脚本
  - 2.13. 继承
  - 2.14. 构造过程
  - 2.15. 析构过程
  - 2.16. 自动引用计数
  - 2.17. 可选链
  - 2.18. 类型检查
  - 2.19. 嵌套类型
  - 2.20. 扩展
  - 2.21. 协议
  - 2.22. 泛型
  - 2.23. 高级操作符
- 3. 语言参考
  - 3.1. 关于语言参考
  - 3.2. 词法结构
  - 3.3. 类型
  - 3.4. 表达式
  - 3.5. 语句
  - 3.6. 声明
  - 3.7. 特性
  - 3.8. 模式
  - 3.9. 泛型参数
  - 3.10. 语法总结
- Generated using GitBook

- 翻译无任何商业目的，仅供内部学习交流使用！

> 翻译：stanzhai
> 校对：xielingwang

# 语法总结

本页包含内容：

- 语句（Statements）
- 泛型参数（Generic Parameters and Arguments）
- 声明（Declarations）
- 模式（Patterns）
- 特性（Attributes）
- 表达式（Expressions）
- 词法结构（Lexical Structure）
- 类型（Types）

## 语句

> 语句语法
> 语句 → 表达式 ; 可选
> 语句 → 声明 ; 可选
> 语句 → 循环语句 ; 可选
> 语句 → 分支语句 ; 可选
> 语句 → 标记语句(Labeled Statement)
> 语句 → 控制转移语句 ; 可选
> 多条语句(Statements) → 语句 多条语句(Statements) 可选

> 循环语句语法
> 循环语句 → for语句
> 循环语句 → for-in语句
> 循环语句 → while语句
> 循环语句 → do-while语句

> For 循环语法
> for语句 → for for初始条件 可选 ; 表达式 可选 ; 表达式 可选 代码块
> for语句 → for ( for初始条件 可选 ; 表达式 可选 ; 表达式 可选 ) 代码块
> for初始条件 → 变量声明 | 表达式列表

> For-In 循环语法
> for-in语句 → for 模式 in 表达式 代码块

> While 循环语法
> while语句 → while while条件 代码块
> while条件 → 表达式 | 声明

> Do-While 循环语法
> do-while语句 → do 代码块 while while条件

> 分支语句语法
> 分支语句 → if语句
> 分支语句 → switch语句

> If语句语法
> if语句 → if if条件 代码块 else子句(Clause) 可选
> if条件 → 表达式 | 声明
> else子句(Clause) → else 代码块 | else if语句

> Switch语句语法
> switch语句 → switch 表达式 { SwitchCase列表 可选 }
> SwitchCase列表 → SwitchCase SwitchCase列表 可选
> SwitchCase → case标签 多条语句(Statements) | default标签 多条语句(Statements)
> SwitchCase → case标签 ; | default标签 ;
> case标签 → case case项列表 :
> case项列表 → 模式 guard-clause 可选 | 模式 guard-clause 可选 , case项列表
> default标签 → default :
> guard-clause → where guard-expression
> guard-expression → 表达式

> 标记语句语法
> 标记语句(Labeled Statement) → 语句标签 循环语句 | 语句标签 switch语句
> 语句标签 → 标签名称 :
> 标签名称 → 标识符

> 控制传递语句(Control Transfer Statement) 语法
> 控制传递语句 → break语句
> 控制传递语句 → continue语句
> 控制传递语句 → fallthrough语句
> 控制传递语句 → return语句

> Break 语句语法
> break语句 → break 标签名称 可选

> Continue 语句语法
> continue语句 → continue 标签名称 可选

> Fallthrough 语句语法
> fallthrough语句 → fallthrough

> Return 语句语法
> return语句 → return 表达式 可选

## 泛型参数

> 泛型形参子句(Generic Parameter Clause) 语法
> 泛型参数子句 → < 泛型参数列表 约束子句 可选 >
> 泛型参数列表 → 泛形参数 | 泛形参数 , 泛型参数列表
> 泛形参数 → 类型名称
> 泛形参数 → 类型名称 : 类型标识
> 泛形参数 → 类型名称 : 协议合成类型
> 约束子句 → where 约束列表
> 约束列表 → 约束 | 约束 , 约束列表
> 约束 → 一致性约束 | 同类型约束
> 一致性约束 → 类型标识 : 类型标识
> 一致性约束 → 类型标识 : 协议合成类型
> 同类型约束 → 类型标识 == 类型标识

> 泛型实参子句语法
> (泛型参数子句Generic Argument Clause) → < 泛型参数列表 >
> 泛型参数列表 → 泛型参数 | 泛型参数 , 泛型参数列表
> 泛型参数 → 类型

## 声明 (Declarations)

> 声明语法
> 声明 → 导入声明
> 声明 → 常量声明
> 声明 → 变量声明
> 声明 → 类型别名声明
> 声明 → 函数声明
> 声明 → 枚举声明
> 声明 → 结构体声明
> 声明 → 类声明
> 声明 → 协议声明
> 声明 → 构造器声明
> 声明 → 析构器声明
> 声明 → 扩展声明
> 声明 → 下标脚本声明
> 声明 → 运算符声明
> 声明(Declarations)列表 → 声明 声明(Declarations)列表 可选
> 声明描述符(Specifiers)列表 → 声明描述符(Specifier) 声明描述符(Specifiers)列表 可选
> 声明描述符(Specifier) → class | mutating | nonmutating | override | static | unowned | unowned(safe) | unowned(unsafe) | weak

> 顶级(Top Level) 声明语法
> 顶级声明 → 多条语句(Statements) 可选

> 代码块语法
> 代码块 → { 多条语句(Statements) 可选 }

> 导入(Import)声明语法
> 导入声明 → 特性(Attributes)列表 可选 import 导入类型 可选 导入路径
> 导入类型 → typealias | struct | class | enum | protocol | var | func
> 导入路径 → 导入路径标识符 | 导入路径标识符 . 导入路径
> 导入路径标识符 → 标识符 | 运算符

> 常数声明语法
> 常量声明 → 特性(Attributes)列表 可选 声明描述符(Specifiers)列表 可选 let 模式构造器列表
> 模式构造器列表 → 模式构造器 | 模式构造器 , 模式构造器列表
> 模式构造器 → 模式 构造器 可选
> 构造器 → = 表达式

> 变量声明语法
> 变量声明 → 变量声明头(Head) 模式构造器列表
> 变量声明 → 变量声明头(Head) 变量名 类型注解 代码块
> 变量声明 → 变量声明头(Head) 变量名 类型注解 getter-setter块
> 变量声明 → 变量声明头(Head) 变量名 类型注解 getter-setter关键字(Keyword)块
> 变量声明 → 变量声明头(Head) 变量名 类型注解 构造器 可选 willSet-didSet代码块
> 变量声明头(Head) → 特性(Attributes)列表 可选 声明描述符(Specifiers)列表 可选 var
> 变量名称 → 标识符
> getter-setter块 → { getter子句 setter子句 可选 }
> getter-setter块 → { setter子句 getter子句 }
> getter子句 → 特性(Attributes)列表 可选 get 代码块
> setter子句 → 特性(Attributes)列表 可选 set setter名称 可选 代码块
> setter名称 → ( 标识符 )
> getter-setter关键字(Keyword)块 → { getter关键字(Keyword)子句 setter关键字(Keyword)子句 可选 }
> getter-setter关键字(Keyword)块 → { setter关键字(Keyword)子句 getter关键字(Keyword)子句 }
> getter关键字(Keyword)子句 → 特性(Attributes)列表 可选 get
> setter关键字(Keyword)子句 → 特性(Attributes)列表 可选 set
> willSet-didSet代码块 → { willSet子句 didSet子句 可选 }
> willSet-didSet代码块 → { didSet子句 willSet子句 }
> willSet子句 → 特性(Attributes)列表 可选 willSet setter名称 可选 代码块
> didSet子句 → 特性(Attributes)列表 可选 didSet setter名称 可选 代码块

> 类型别名声明语法
> 类型别名声明 → 类型别名头(Head) 类型别名赋值
> 类型别名头(Head) → typealias 类型别名名称
> 类型别名名称 → 标识符
> 类型别名赋值 → = 类型

> 函数声明语法
> 函数声明 → 函数头 函数名 泛型参数子句 可选 函数签名(Signature) 函数体
> 函数头 → 特性(Attributes)列表 可选 声明描述符(Specifiers)列表 可选 func
> 函数名 → 标识符 | 运算符
> 函数签名(Signature) → parameter-clauses 函数结果 可选
> 函数结果 → -> 特性(Attributes)列表 可选 类型
> 函数体 → 代码块
> parameter-clauses → 参数子句 parameter-clauses 可选
> 参数子句 → ( ) | ( 参数列表 ... 可选 )
> 参数列表 → 参数 | 参数 , 参数列表
> 参数 → inout 可选 let 可选 # 可选 参数名 本地参数名 可选 类型注解 默认参数子句 可选
> 参数 → inout 可选 var # 可选 参数名 本地参数名 可选 类型注解 默认参数子句 可选
> 参数 → 特性(Attributes)列表 可选 类型
> 参数名 → 标识符 | _
> 本地参数名 → 标识符 | _
> 默认参数子句 → = 表达式

> 枚举声明语法
> 枚举声明 → 特性(Attributes)列表 可选 联合式枚举 | 特性(Attributes)列表 可选 原始值式枚举
> 联合式枚举 → 枚举名 泛型参数子句 可选 { union-style-enum-members 可选 }
> union-style-enum-members → union-style-enum-member union-style-enum-members 可选
> union-style-enum-member → 声明 | 联合式(Union Style)的枚举case子句
> 联合式(Union Style)的枚举case子句 → 特性(Attributes)列表 可选 case 联合式(Union Style)的枚举case列表
> 联合式(Union Style)的枚举case列表 → 联合式(Union Style)的case | 联合式(Union Style)的case , 联合式(Union Style)的枚举case列表
> 联合式(Union Style)的case → 枚举的case名 元组类型 可选
> 枚举名 → 标识符
> 枚举的case名 → 标识符
> 原始值式枚举 → 枚举名 泛型参数子句 可选 : 类型标识 { 原始值式枚举成员列表 可选 }
> 原始值式枚举成员列表 → 原始值式枚举成员 原始值式枚举成员列表 可选
> 原始值式枚举成员 → 声明 | 原始值式枚举case子句
> 原始值式枚举case子句 → 特性(Attributes)列表 可选 case 原始值式枚举case列表
> 原始值式枚举case列表 → 原始值式枚举case | 原始值式枚举case , 原始值式枚举case列表
> 原始值式枚举case → 枚举的case名 原始值赋值 可选
> 原始值赋值 → = 字面量

> 结构体声明语法
> 结构体声明 → 特性(Attributes)列表 可选 struct 结构体名称 泛型参数子句 可选 类型继承子句 可选 结构体主体
> 结构体名称 → 标识符
> 结构体主体 → { 声明(Declarations)列表 可选 }

> 类声明语法
> 类声明 → 特性(Attributes)列表 可选 class 类名 泛型参数子句 可选 类型继承子句 可选 类主体
> 类名 → 标识符
> 类主体 → { 声明(Declarations)列表 可选 }

> 协议(Protocol)声明语法
> 协议声明 → 特性(Attributes)列表 可选 protocol 协议名 类型继承子句 可选 协议主体
> 协议名 → 标识符
> 协议主体 → { 协议成员声明(Declarations)列表 可选 }
> 协议成员声明 → 协议属性声明
> 协议成员声明 → 协议方法声明
> 协议成员声明 → 协议构造器声明
> 协议成员声明 → 协议下标脚本声明
> 协议成员声明 → 协议关联类型声明
> 协议成员声明(Declarations)列表 → 协议成员声明 协议成员声明(Declarations)列表 可选

> 协议属性声明语法
> 协议属性声明 → 变量声明头(Head) 变量名 类型注解 getter-setter关键字(Keyword)块

> 协议方法声明语法
> 协议方法声明 → 函数头 函数名 泛型参数子句 可选 函数签名(Signature)

> 协议构造器声明语法
> 协议构造器声明 → 构造器头(Head) 泛型参数子句 可选 参数子句

> 协议下标脚本声明语法
> 协议下标脚本声明 → 下标脚本头(Head) 下标脚本结果(Result) getter-setter关键字(Keyword)块

> 协议关联类型声明语法
> 协议关联类型声明 → 类型别名头(Head) 类型继承子句 可选 类型别名赋值 可选

> 构造器声明语法
> 构造器声明 → 构造器头(Head) 泛型参数子句 可选 参数子句 构造器主体
> 构造器头(Head) → 特性(Attributes)列表 可选 convenience 可选 init
> 构造器主体 → 代码块

> 析构器声明语法
> 析构器声明 → 特性(Attributes)列表 可选 deinit 代码块

> 扩展(Extension)声明语法
> 扩展声明 → extension 类型标识 类型继承子句 可选 extension-body
> extension-body → { 声明(Declarations)列表 可选 }

> 下标脚本声明语法
> 下标脚本声明 → 下标脚本头(Head) 下标脚本结果(Result) 代码块
> 下标脚本声明 → 下标脚本头(Head) 下标脚本结果(Result) getter-setter块
> 下标脚本声明 → 下标脚本头(Head) 下标脚本结果(Result) getter-setter关键字(Keyword)块
> 下标脚本头(Head) → 特性(Attributes)列表 可选 subscript 参数子句
> 下标脚本结果(Result) → -> 特性(Attributes)列表 可选 类型

> 运算符声明语法
> 运算符声明 → 前置运算符声明 | 后置运算符声明 | 中置运算符声明
> 前置运算符声明 → 运算符 prefix 运算符 { }
> 后置运算符声明 → 运算符 postfix 运算符 { }
> 中置运算符声明 → 运算符 infix 运算符 { 中置运算符属性 可选 }
> 中置运算符属性 → 优先级子句 可选 结和性子句 可选
> 优先级子句 → precedence 优先级水平
> 优先级水平 → 数值 0 到 255
> 结和性子句 → associativity 结和性
> 结和性 → left | right | none

## 模式

> 模式(Patterns) 语法
> 模式 → 通配符模式 类型注解 可选
> 模式 → 标识符模式 类型注解on) 可选
> 模式 → 值绑定模式
> 模式 → 元组模式 类型注解 可选
> 模式 → enum-case-pattern
> 模式 → type-casting-pattern
> 模式 → 表达式模式

> 通配符模式语法
> 通配符模式 → _

> 标识符模式语法
> 标识符模式 → 标识符

> 值绑定(Value Binding)模式语法
> 值绑定模式 → var 模式 | let 模式

> 元组模式语法
> 元组模式 → ( 元组模式元素列表 可选 )
> 元组模式元素列表 → 元组模式元素 | 元组模式元素 , 元组模式元素列表
> 元组模式元素 → 模式

> 枚举用例模式语法
> enum-case-pattern → 类型标识 可选 . 枚举的case名 元组模式 可选

> 类型转换模式语法
> type-casting-pattern → is模式 | as模式
> is模式 → is 类型
> as模式 → 模式 as 类型

> 表达式模式语法
> 表达式模式 → 表达式

## 特性

> 特性语法
> 特色 → @ 特性名 特性参数子句 可选
> 特性名 → 标识符
> 特性参数子句 → ( 平衡令牌列表 可选 )
> 特性(Attributes)列表 → 特色 特性(Attributes)列表 可选
> 平衡令牌列表 → 平衡令牌 平衡令牌列表 可选
> 平衡令牌 → ( 平衡令牌列表 可选 )
> 平衡令牌 → [ 平衡令牌列表 可选 ]
> 平衡令牌 → { 平衡令牌列表 可选 }
> 平衡令牌 → 任意标识符, 关键字, 字面量或运算符
> 平衡令牌 → 任意标点除了(, ), [, ], {, 或 }

## 表达式

> 表达式语法
> 表达式 → 前置表达式 二元表达式列表 可选
> 表达式列表 → 表达式 | 表达式 , 表达式列表

> 前置表达式语法
> 前置表达式 → 前置运算符 可选 后置表达式
> 前置表达式 → 写入写出(in-out)表达式
> 写入写出(in-out)表达式 → & 标识符

> 二元表达式语法
> 二元表达式 → 二元运算符 前置表达式
> 二元表达式 → 赋值运算符 前置表达式
> 二元表达式 → 条件运算符 前置表达式
> 二元表达式 → 类型转换运算符
> 二元表达式列表 → 二元表达式 二元表达式列表 可选

> 赋值运算符语法
> 赋值运算符 → =

> 三元条件运算符语法
> 三元条件运算符 → ? 表达式 :

> 类型转换运算符语法
> 类型转换运算符 → is 类型 | as ? 可选 类型

> 主表达式语法
> 主表达式 → 标识符 泛型参数子句 可选
> 主表达式 → 字面量表达式
> 主表达式 → self表达式
> 主表达式 → 超类表达式
> 主表达式 → 闭包表达式
> 主表达式 → 圆括号表达式
> 主表达式 → 隐式成员表达式
> 主表达式 → 通配符表达式

> 字面量表达式语法
> 字面量表达式 → 字面量
> 字面量表达式 → 数组字面量 | 字典字面量
> 字面量表达式 → __FILE__ | __LINE__ | __COLUMN__ | __FUNCTION__
> 数组字面量 → [ 数组字面量项列表 可选 ]
> 数组字面量项列表 → 数组字面量项 , 可选 | 数组字面量项 , 数组字面量项列表
> 数组字面量项 → 表达式
> 字典字面量 → [ 字典字面量项列表 ] | [ : ]
> 字典字面量项列表 → 字典字面量项 , 可选 | 字典字面量项 , 字典字面量项列表
> 字典字面量项 → 表达式 : 表达式

> Self 表达式语法
> self表达式 → self
> self表达式 → self . 标识符
> self表达式 → self [ 表达式 ]
> self表达式 → self . init

> 超类表达式语法
> 超类表达式 → 超类方法表达式 | 超类下标表达式 | 超类构造器表达式
> 超类方法表达式 → super . 标识符
> 超类下标表达式 → super [ 表达式 ]
> 超类构造器表达式 → super . init

> 闭包表达式语法
> 闭包表达式 → { 闭包签名(Signational) 可选 多条语句(Statements) }
> 闭包签名(Signational) → 参数子句 函数结果 可选 in
> 闭包签名(Signational) → 标识符列表 函数结果 可选 in
> 闭包签名(Signational) → 捕获(Capature)列表 参数子句 函数结果 可选 in
> 闭包签名(Signational) → 捕获(Capature)列表 标识符列表 函数结果 可选 in
> 闭包签名(Signational) → 捕获(Capature)列表 in
> 捕获(Capature)列表 → [ 捕获(Capature)说明符 表达式 ]
> 捕获(Capature)说明符 → weak | unowned | unowned(safe) | unowned(unsafe)

> 隐式成员表达式语法
> 隐式成员表达式 → . 标识符

> 圆括号表达式(Parenthesized Expression)语法
> 圆括号表达式 → ( 表达式元素列表 可选 )
> 表达式元素列表 → 表达式元素 | 表达式元素 , 表达式元素列表
> 表达式元素 → 表达式 | 标识符 : 表达式

> 通配符表达式语法
> 通配符表达式 → _

> 后置表达式语法
> 后置表达式 → 主表达式
> 后置表达式 → 后置表达式 后置运算符
> 后置表达式 → 函数调用表达式
> 后置表达式 → 构造器表达式
> 后置表达式 → 显示成员表达式
> 后置表达式 → 后置self表达式
> 后置表达式 → 动态类型表达式
> 后置表达式 → 下标表达式
> 后置表达式 → 强制取值(Forced Value)表达式
> 后置表达式 → 可选链(Optional Chaining)表达式

> 函数调用表达式语法
> 函数调用表达式 → 后置表达式 圆括号表达式
> 函数调用表达式 → 后置表达式 圆括号表达式 可选 后置闭包(Trailing Closure)
> 后置闭包(Trailing Closure) → 闭包表达式

> 构造器表达式语法
> 构造器表达式 → 后置表达式 . init

> 显式成员表达式语法
> 显示成员表达式 → 后置表达式 . 十进制数字
> 显示成员表达式 → 后置表达式 . 标识符 泛型参数子句 可选

> 后置Self 表达式语法
> 后置self表达式 → 后置表达式 . self

> 动态类型表达式语法
> 动态类型表达式 → 后置表达式 . dynamicType

> 附属脚本表达式语法
> 附属脚本表达式 → 后置表达式 [ 表达式列表 ]

> 强制取值(Forced Value)语法
> 强制取值(Forced Value)表达式 → 后置表达式 !

> 可选链表达式语法
> 可选链表达式 → 后置表达式 ?

## 词法结构

> 标识符语法
> 标识符 → 标识符头(Head) 标识符字符列表 可选
> 标识符 → ` 标识符头(Head) 标识符字符列表 可选 `
> 标识符 → 隐式参数名
> 标识符列表 → 标识符 | 标识符 , 标识符列表
> 标识符头(Head) → Upper- or lowercase letter A through Z
> 标识符头(Head) → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
> 标识符头(Head) → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
> 标识符头(Head) → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
> 标识符头(Head) → U+1E00–U+1FFF
> 标识符头(Head) → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
> 标识符头(Head) → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
> 标识符头(Head) → U+2C00–U+2DFF or U+2E80–U+2FFF
> 标识符头(Head) → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
> 标识符头(Head) → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
> 标识符头(Head) → U+FE47–U+FFFD
> 标识符头(Head) → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
> 标识符头(Head) → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
> 标识符头(Head) → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
> 标识符头(Head) → U+D0000–U+DFFFD or U+E0000–U+EFFFD
> 标识符字符 → 数值 0 到 9
> 标识符字符 → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
> 标识符字符 → 标识符头(Head)
> 标识符字符列表 → 标识符字符 标识符字符列表 可选
> 隐式参数名 → $ 十进制数字列表

> 字面量语法
> 字面量 → 整型字面量 | 浮点数字面量 | 字符串字面量

> 整型字面量语法
> 整型字面量 → 二进制字面量
> 整型字面量 → 八进制字面量
> 整型字面量 → 十进制字面量
> 整型字面量 → 十六进制字面量
> 二进制字面量 → 0b 二进制数字 二进制字面量字符列表 可选
> 二进制数字 → 数值 0 到 1
> 二进制字面量字符 → 二进制数字 | _
> 二进制字面量字符列表 → 二进制字面量字符 二进制字面量字符列表 可选
> 八进制字面量 → 0o 八进字数字 八进制字符列表 可选
> 八进字数字 → 数值 0 到 7
> 八进制字符 → 八进字数字 | _
> 八进制字符列表 → 八进制字符 八进制字符列表 可选
> 十进制字面量 → 十进制数字 十进制字符列表 可选
> 十进制数字 → 数值 0 到 9
> 十进制数字列表 → 十进制数字 十进制数字列表 可选
> 十进制字符 → 十进制数字 | _
> 十进制字符列表 → 十进制字符 十进制字符列表 可选
> 十六进制字面量 → 0x 十六进制数字 十六进制字面量字符列表 可选
> 十六进制数字 → 数值 0 到 9, a through f, or A through F
> 十六进制字符 → 十六进制数字 | _
> 十六进制字面量字符列表 → 十六进制字符 十六进制字面量字符列表 可选

> 浮点型字面量语法
> 浮点数字面量 → 十进制字面量 十进制分数 可选 十进制指数 可选
> 浮点数字面量 → 十六进制字面量 十六进制分数 可选 十六进制指数
> 十进制分数 → . 十进制字面量
> 十进制指数 → 浮点数e 正负号 可选 十进制字面量
> 十六进制分数 → . 十六进制字面量 可选
> 十六进制指数 → 浮点数p 正负号 可选 十六进制字面量
> 浮点数e → e | E
> 浮点数p → p | P
> 正负号 → + | -

> 字符型字面量语法
> 字符串字面量 → " 引用文本 "
> 引用文本 → 引用文本条目 引用文本 可选
> 引用文本条目 → 转义字符
> 引用文本条目 → ( 表达式 )
> 引用文本条目 → 除了", \, U+000A, or U+000D的所有Unicode的字符
> 转义字符 → \0 | \ | \t | \n | \r | \" | \'
> 转义字符 → \x 十六进制数字 十六进制数字
> 转义字符 → \u 十六进制数字 十六进制数字 十六进制数字 十六进制数字
> 转义字符 → \U 十六进制数字 十六进制数字 十六进制数字 十六进制数字 十六进制数字 十六进制数字 十六进制数字 十六进制数字

> 运算符语法语法
> 运算符 → 运算符字符 运算符 可选
> 运算符字符 → / | = | - | + | ! | * | % | < | > | & | | | ^ | ~ | .
> 二元运算符 → 运算符
> 前置运算符 → 运算符
> 后置运算符 → 运算符

## 类型

> 类型语法
> 类型 → 数组类型 | 函数类型 | 类型标识 | 元组类型 | 可选类型 | 隐式解析可选类型 | 协议合成类型 | 元型类型

> 类型注解语法
> 类型注解 → : 特性(Attributes)列表 可选 类型

> 类型标识语法
> 类型标识 → 类型名称 泛型参数子句 可选 | 类型名称 泛型参数子句 可选 . 类型标识
> 类名 → 标识符

> 元组类型语法
> 元组类型 → ( 元组类型主体 可选 )
> 元组类型主体 → 元组类型的元素列表 ... 可选
> 元组类型的元素列表 → 元组类型的元素 | 元组类型的元素 , 元组类型的元素列表
> 元组类型的元素 → 特性(Attributes)列表 可选 inout 可选 类型 | inout 可选 元素名 类型注解
> 元素名 → 标识符

> 函数类型语法
> 函数类型 → 类型 -> 类型

> 数组类型语法
> 数组类型 → 类型 [ ] | 数组类型 [ ]

> 可选类型语法
> 可选类型 → 类型 ?

> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法
> 隐式解析可选类型 → 类型 !

> 协议合成类型语法
> 协议合成类型 → protocol < 协议标识符列表 可选 >
> 协议标识符列表 → 协议标识符 | 协议标识符 , 协议标识符列表
> 协议标识符 → 类型标识

> 元(Metatype)类型语法
> 元类型 → 类型 . Type | 类型 . Protocol

> 类型继承子句语法
> 类型继承子句 → : 类型继承列表
> 类型继承列表 → 类型标识 | 类型标识 , 类型继承列表