译者序

本书是 《The Rust Reference》 的中文翻译，译者仿照其他语言惯例译作《Rust 参考手册》。《The Rust Reference》编写的是 Rust 这门计算机语言的规则、规范，记录了权威、完整、可查阅的 Rust 语言细节，包含语言语法、语义、特性等详实的内容，是深入了解 Rust 语言不可或缺的学习资料。

在翻译过程中，译者首先通过 DeepSeek 对全书进行初翻，随后人工通读全篇并对照上游代码的改动进行校对。翻译力求严谨、忠实原文，尽可能保持原文档的结构、语气与信息密度，不擅自增删文字细节，只在英文长句或被动语态影响中文阅读流畅性时，进行适度意译的调整，不改变原意。在专有名词、概念等术语上，译者参照了 《Rust 程序设计语言 简体中文版》 等社区中高质量的中文翻译内容，以期诸位读者在读到本书译文时，不会对某些概念或专有名词的翻译感到困惑。同时，代码与格式力求规范，每次提交均根据《Rust 参考手册开发者指南》中的运行测试板块进行格式与链接检查，力争保证输出内容的质量。

本书翻译的是《The Rust Reference》的 nightly 版本，这可能与您在其他地方看到的 stable 版本 的内容有些许不同。

本书的翻译通过同步上游仓库代码、翻译内容变化部分的方式保持所有翻译内容为最新。当前翻译的英文原文提交哈希为 5d5be50f，提交时间为 2026 年 5 月 21 日。

您可以通过以下方式阅读本书：

• 在线阅读：《Rust 参考手册》
• PDF 下载：从仓库的 Release 页面 下载
• 本地构建：参考 CONTRIBUTING.md 的构建与测试板块，下载项目后构建 HTML 文件，进一步本地生成 PDF

本书专业性强，译者能力有限，翻译难免会有疏漏和欠妥之处，恳请各位读者批评指正。如果您在阅读过程中发现任何问题，欢迎到项目仓库提交 Issues 或 Pull Requests 参与贡献翻译内容。

引言

本书是 Rust 编程语言的主要参考手册。

Rust 版本发布

Rust 每六周发布一个新语言版本。 该语言的第一个稳定版本是 Rust 1.0.0，随后是 Rust 1.1.0，依此类推。 工具（rustc、cargo 等）和文档（标准库、本书等）随语言版本一起发布。

本书的最新版本（与最新的 Rust 版本对应）始终可以在 https://doc.rust-lang.org/reference/ 找到。 之前的版本可以通过在 “reference” 目录前添加 Rust 版本来找到。 例如，Rust 1.49.0 的参考手册位于 https://doc.rust-lang.org/1.49.0/reference/。

《Rust 参考手册》不是什么

本书不作为语言入门教程。 假定读者已经具备该语言的背景知识。 有一本配套书籍可用来帮助获得这种背景知识。

本书也不作为语言发行版中包含的标准库的参考。 这些库的文档是通过从其源代码中提取文档属性来单独生成的。 许多人们可能认为是语言特性的东西实际上是 Rust 中的库特性，所以你要找的内容可能在那里，而不是这里。

同样，本书通常不记录 rustc 作为工具或 Cargo 的具体细节。 rustc 有自己的手册。 Cargo 有一本手册，其中包含一个参考。 但仍有少数页面（例如链接）描述了 rustc 的工作方式。

本书也仅作为稳定版 Rust 中可用内容的参考。 关于正在开发中的不稳定特性，请参阅不稳定特性手册。

Rust 编译器（包括 rustc）会执行优化。 本参考手册不指定哪些优化是允许或不允许的。 相反，可以把编译后的程序看作一个黑盒。 你只能通过运行它、给它输入并观察其输出来探测它。 通过这种方式发生的一切都必须符合本参考手册的规定。

如何使用本书

本书并不假设你是按顺序阅读的。 每章通常可以独立阅读，但会交叉链接到其他章节，以引用它们涉及但未讨论的语言层面。

阅读本文档主要有两种方式。

第一种是回答特定问题。 如果你知道哪个章节回答了该问题，可以直接跳到目录中的该章。 否则，你可以按 s 键或点击顶部栏的放大镜图标，搜索与问题相关的关键词。 例如，你想知道 let 语句中创建的临时值何时被丢弃。 如果你还不知道临时值的生命周期是在表达式章节中定义的，你可以搜索 “temporary let”，第一个搜索结果就会带你到那一节。

第二种是全面提升你对语言某个层面的了解。 在这种情况下，只需浏览目录，直到看到你想进一步了解的内容，然后开始阅读。 如果某个链接看起来有趣，点击它并阅读该节。

话虽如此，阅读本书没有错误的方式。以你觉得最有帮助的方式阅读即可。

约定

与所有技术书籍一样，本书在信息展示方面有一些约定。 这些约定记录在此处。

• 定义术语的语句将该术语以斜体显示。 每当该术语在该章之外使用时，通常是一个指向包含此定义的小节的链接。

  示例术语就是一个正在被定义的术语的示例。

• 正文描述最新的稳定版本。与先前版本的差异在版本块中单独说明：

  2018 Edition differences

  在 2018 版本之前，行为是这样的。从 2018 版本开始，行为是那样的。

• 包含关于本书状态的有用信息或指出有用但大多超出范围的信息的注释，放在注释块中。

  Note

  这是一个示例注释。

• 示例块展示演示某个规则或指出某些有趣方面的示例。有些示例可能有隐藏行，可以通过将鼠标悬停或点击示例时出现的眼睛图标来查看。

  Example

  这是一个代码示例。

  #![allow(unused)]
  fn main() {
  println!("hello world");
  }

• 展示语言中的不安全行为或可能令人困惑的语言特性交互的警告，放在特殊的警告框中。

  Warning

  这是一个示例警告。

• 文本中的内联代码片段放在 <code> 标签内。

  较长的代码示例放在语法高亮的框中，右上角有复制、执行和显示隐藏行的控件。

  // 这是隐藏行。
  fn main() {
      println!("This is a code example");
  }

  除非另有说明，所有示例都针对最新版本编写。

• 语法和词法产生式在记法章节中描述。

• 规则标识符出现在每个语言规则之前，用方括号括起来。这些标识符提供了一种引用和链接到语言中特定规则的方式（例如）。规则标识符使用句点将各部分从最通用到最具体地分隔开（例如 destructors.scope.nesting.function-body）。在窄屏幕上，规则名称会折叠显示为 [*]。

  点击规则名称可以链接到该规则。

  Warning

  规则的组织方式目前尚在调整中。目前，这些标识符名称在各版本之间并不稳定，如果发生变化，指向这些规则的链接可能会失效。我们计划在组织方式稳定后，使得指向规则名称的链接在版本之间不会断开。

• 有关联测试的规则会在其下方包含一个 Tests 链接（在窄屏幕上，链接为 [T]）。点击该链接会弹出一个测试列表，可以点击查看测试。例如，参见 input.encoding.utf8。

  将规则链接到测试是一项持续进行的工作。概览请参见测试摘要章节。

贡献

我们欢迎各种形式的贡献。

你可以通过向 the Rust Reference repository 提交 issue 或 pull request 来为本书做出贡献。 如果本书没有回答你的问题，并且你认为答案属于本书的范围，请随时提交 issue或在 Zulip 上的 t-lang/doc 频道中询问。 了解人们最常将本书用于什么目的，有助于我们将注意力集中在使这些章节尽可能完善上。 当然，如果你看到任何错误或非规范性但未明确标明的内容，也请提交 issue。

记法

语法

以下记法约定用于词法分析器和语法片段：

序列的优先级高于 | 交替。

硬切割运算符

该语法使用有序交替：解析器从左到右尝试各分支，采纳第一个匹配的分支。如果某个分支在序列中途失败，解析器通常回溯并尝试下一个分支。切割运算符（^）可以阻止这种情况。一旦序列中 ^ 左侧的所有表达式都已匹配，序列剩余部分必须匹配，否则解析将无条件失败。

Mizushima 等人将切割运算符引入了解析表达式文法。在 PEG 文献中，软切割仅阻止在最内层有序选择的范围内回溯——外层选择仍可恢复。硬切割则阻止切割点之后的所有回溯；失败是确定性的。本语法中使用的 ^ 是硬切割。

硬切割运算符是必要的，因为 Rust 中的某些 token 以本身也是合法 token 的前缀开头。例如，c" 开始一个 C 字符串字面量，但单独的 c 是一个合法的标识符。如果没有切割，当 c"\0" 无法被词法分析为 C 字符串字面量时（因为 C 字符串不允许空字节），解析器可能回溯并将其词法分析为两个 token：标识符 c 和字符串字面量 "\0"。c" 后的切割可以防止这种情况——一旦识别出起始定界符，解析器就不能回退。同样的原理适用于字节字面量、字节字符串字面量、原始字符串字面量以及其他以前缀开头的字面量，这些前缀本身也是合法的 token。

字符串表产生式

语法中的某些规则——特别是一元运算符、二元运算符和关键字——以简化形式给出：作为可打印字符串的列表。这些情况构成了关于 token 规则的一个子集，并假定是向解析器提供输入的词法分析阶段的结果，该阶段由 DFA 驱动，操作于所有此类字符串表条目的析取之上。

当语法中出现 monospace 字体的字符串时，它是对此类字符串表产生式中单个成员的隐式引用。详见 token 词法单元。

语法可视化

每个语法块下方有一个按钮，可以切换显示语法图。方形元素是非终结规则，圆角矩形是终结符。

词法结构

输入格式

本章描述源文件如何被解释为 token 序列。

关于程序如何组织为文件的描述，请参阅 crate 和源文件。

源文件编码

每个源文件被解释为以 UTF-8 编码的 Unicode 字符序列。

如果文件不是有效的 UTF-8，则视为错误。

字节顺序标记移除

如果序列中的第一个字符是 U+FEFF（BYTE ORDER MARK），则将其移除。

CRLF 规范化

每对字符 U+000D（CR）后紧跟 U+000A（LF）将被替换为单个 U+000A（LF）。此过程仅执行一次，而非重复执行，因此规范化之后，输入中仍可能存在紧跟 U+000A（LF）的 U+000D（CR）（例如，原始输入包含 “CR CR LF LF”）。

其他位置的字符 U+000D（CR）将保留（它们被视为空白字符）。

Shebang 移除

如果存在 shebang，则将其从输入序列中移除（因此被忽略）。

Token 化

然后将生成的字符序列转换为 token，具体描述见本章其余部分。

Shebang

Shebang 是一个可选行，通常用于类 Unix 系统中，用来指定执行该文件的解释器。

Shebang 以字符 #! 开头，并延伸到第一个 U+000A（LF）处，如果没有 LF 则延伸到 EOF。如果 #! 字符后面跟随 [（忽略中间的注释或空白字符），则该行不被视为 shebang（以避免与内部属性产生歧义）。

Shebang 可以紧接在文件开头出现，也可以出现在可选的字节顺序标记之后。

关键字

Rust 将关键字分为三类：

• 严格关键字
• 保留关键字
• 弱关键字

严格关键字

这些关键字只能在其正确的上下文中使用。它们不能用作以下名称：

• 程序项
• 变量和函数参数
• 字段和变体
• 类型参数
• 生命周期参数或循环标签
• 宏或属性
• 宏占位符
• crate

以下关键字在所有版本中均存在：

• _
• as
• async
• await
• break
• const
• continue
• crate
• dyn
• else
• enum
• extern
• false
• fn
• for
• if
• impl
• in
• let
• loop
• match
• mod
• move
• mut
• pub
• ref
• return
• self
• Self
• static
• struct
• super
• trait
• true
• type
• unsafe
• use
• where
• while

保留关键字

这些关键字尚未使用，但为将来使用而保留。它们与严格关键字具有相同的限制。这样做的原因是禁止程序使用这些关键字，从而使当前程序与未来的 Rust 版本保持向前兼容。

• abstract
• become
• box
• do
• final
• gen
• macro
• override
• priv
• try
• typeof
• unsized
• virtual
• yield

弱关键字

这些关键字仅在特定上下文中具有特殊含义。例如，可以用 union 这个名称声明变量或方法。

• 'static
• macro_rules
• raw
• safe
• union

• macro_rules 用于创建自定义宏。

• union 用于声明联合体，且仅在联合体声明中才是关键字。

• 'static 用于静态生命周期，不能用作泛型生命周期参数或循环标签

  // 错误[E0262]: 无效的生存期参数名称: `'static`
  fn invalid_lifetime_parameter<'static>(s: &'static str) -> &'static str { s }
  

• safe 用于函数和静态项，在外部块中具有含义。

• raw 用于原始借用运算符，且仅在匹配原始借用运算符形式（如 &raw const expr 或 &raw mut expr）时才是关键字。

标识符

标识符遵循 Unicode 标准附录 #31 中 Unicode 版本 17.0 的规范，并包含下文所述的补充。以下是一些标识符的示例：

• foo
• _identifier
• r#true
• Москва
• 東京

UAX #31 使用的配置为：

• Start := XID_Start，加上下划线字符（U+005F）
• Continue := XID_Continue
• Medial := 空

标识符不能是严格或保留关键字，除非使用下文原始标识符中描述的 r# 前缀。

零宽度非连接符（ZWNJ U+200C）和零宽度连接符（ZWJ U+200D）字符不允许出现在标识符中。

在以下情况下，标识符仅限于 XID_Start 和 XID_Continue 的 ASCII 子集：

• extern crate 声明（除 AsClause 标识符外）
• 在路径中引用的外部 crate 名称
• 从文件系统加载且不带 path 属性的模块名称
• 带有 no_mangle 属性的程序项
• 外部块中的程序项名称

规范化

标识符使用 Unicode 标准附录 #15 中定义的规范化形式 C（NFC）进行规范化。如果两个标识符的 NFC 形式相等，则它们相等。

过程宏和声明宏在其输入中接收规范化后的标识符。

原始标识符

原始标识符类似于普通标识符，但带有 r# 前缀。（注意，r# 前缀不算作实际标识符的一部分。）

与普通标识符不同，原始标识符可以使用任何严格或保留关键字，但 RAW_IDENTIFIER 中以上列出的除外。

使用 RESERVED_RAW_IDENTIFIER token 是错误的。

注释

非文档注释

注释遵循通用的 C++ 风格，支持行（//）和块（/* ... */）注释形式。支持嵌套块注释。

非文档注释被解释为一种空白字符。

文档注释

以恰好三条斜杠（///）开头的行文档注释，以及块文档注释（/** ... */），都是外部文档注释，会被解释为 doc 属性 的特殊语法。

也就是说，它们等价于在注释主体周围书写 #[doc="..."]，即 /// Foo 转变为 #[doc=" Foo"]，/** Bar */ 转变为 #[doc=" Bar "]。它们因此必须出现在接受外部属性的项之前。

以 //! 开头的行注释和块注释 /*! ... */ 是应用于注释父项的文档注释，而不是应用于其后跟随的项。

也就是说，它们等价于在注释主体周围书写 #![doc="..."]。//! 注释通常用于为占据一个源文件的模块编写文档。

字符 U+000D（CR）不允许出现在文档注释中。

示例

#![allow(unused)]
fn main() {
//! 应用于此 crate 的隐式匿名模块的文档注释

pub mod outer_module {

    //!  - 内部行文档注释
    //!! - 仍然是内部行文档注释（但开头有一个感叹号）

    /*!  - 内部块文档注释 */
    /*!! - 仍然是内部块文档注释（但开头有一个感叹号） */

    //   - 仅是一个注释
    ///  - 外部行文档注释（恰好 3 条斜杠）
    //// - 仅是一个注释

    /*   - 仅是一个注释 */
    /**  - 外部块文档注释（恰好 2 个星号） */
    /*** - 仅是一个注释 */

    pub mod inner_module {}

    pub mod nested_comments {
        /* Rust 中 /* 我们可以 /* 嵌套注释 */ */ */

        // 所有三种块注释都可以包含或被嵌套在任何其他类型的注释中：

        /*   /* */  /** */  /*! */  */
        /*!  /* */  /** */  /*! */  */
        /**  /* */  /** */  /*! */  */
        pub mod dummy_item {}
    }

    pub mod degenerate_cases {
        // 空内部行文档注释
        //!

        // 空内部块文档注释
        /*!*/

        // 空行注释
        //

        // 空外部行文档注释
        ///

        // 空块注释
        /**/

        pub mod dummy_item {}

        // 空 2 星号块不是文档块，而是块注释
        /***/

    }

    /* 下一个是不允许的，因为外层文档注释需要一个接收该文档的项 */

    /// 我的项在哪里？
  mod boo {}
}
}

空白字符

空白字符是指任何非空字符串，其中仅包含具有 Pattern_White_Space Unicode 属性的字符。

Rust 是一种“自由格式“语言，这意味着所有形式的空白字符仅用于分隔语法中的 token，没有语义意义。

如果将一个 Rust 程序中的每个空白字符元素替换为任意其他合法的空白字符元素（如单个空格字符），程序将具有相同的含义。

Token

Token 是语法中由正则（非递归）语言定义的基本产生式。Rust 源代码可以分解为以下几种 token：

• 关键字
• 标识符
• 字面量
• 生命周期
• 标点符号
• 定界符

在本文档的语法中，“简单” token 以字符串表产生式的形式给出，并以 monospace 字体呈现。

字面量

字面量是用于字面量表达式的 token。

示例

字符与字符串

ASCII 转义

字节转义

Unicode 转义

引号转义

数字

后缀

后缀是一串紧跟在字面量主体部分之后（中间没有空白字符）的字符，其形式与非原始标识符或关键字相同。

任何类型的字面量（字符串、整数等）带有任意后缀作为 token 都是合法的。

带任意后缀的字面量 token 可以传递给宏而不会产生错误。宏本身将决定如何解释这样的 token 以及是否报错。特别是，按示例宏的 literal 片段限定符可以匹配带任意后缀的字面量 token。

#![allow(unused)]
fn main() {
macro_rules! blackhole { ($tt:tt) => () }
macro_rules! blackhole_lit { ($l:literal) => () }

blackhole!("string"suffix); // OK
blackhole_lit!(1suffix); // OK
}

然而，在被解释为字面量表达式或模式时，字面量 token 的后缀是受限的。非数字字面量 token 上的任何后缀都会被拒绝，而数字字面量 token 仅接受下表中的后缀。

字符与字符串字面量

字符字面量

字符字面量是包含在两个 U+0027（单引号）字符之间的单个 Unicode 字符，但 U+0027 本身除外，它必须由前置的 U+005C 字符（\）进行转义。

字符串字面量

字符串字面量是包含在两个 U+0022（双引号）字符之间的任意 Unicode 字符序列，但 U+0022 本身除外，它必须由前置的 U+005C 字符（\）进行转义。

字符串字面量中允许换行，由字符 U+000A（LF）表示。字符 U+000D（CR）不能出现在字符串字面量中。当未转义的 U+005C 字符（\）紧接在换行之前出现时，该换行不会出现在 token 所表示的字符串中。详见字符串续行转义。

字符转义

在字符字面量或非原始字符串字面量中，还可以使用一些额外的转义。转义以 U+005C（\）开头，并以下列形式之一继续：

• 7 位码点转义以 U+0078（x）开头，后跟恰好两位十六进制数字，值最大为 0x7F。它表示与提供的十六进制值相等的 ASCII 字符。不允许更高的值，因为无法确定它表示的是 Unicode 码点还是字节值。

• 24 位码点转义以 U+0075（u）开头，后跟最多六位十六进制数字，并用花括号 U+007B（{）和 U+007D（}）包围。它表示与提供的十六进制值相等的 Unicode 码点。该值必须是合法的 Unicode 标量值。

• 空白转义是字符 U+006E（n）、U+0072（r）或 U+0074（t）之一，分别表示 Unicode 值 U+000A（LF）、U+000D（CR）或 U+0009（HT）。

• 空转义是字符 U+0030（0），表示 Unicode 值 U+0000（NUL）。

• 反斜杠转义是字符 U+005C（\），必须进行转义才能表示其自身。

原始字符串字面量

原始字符串字面量不处理任何转义。它们以字符 U+0072（r）开头，后跟少于 256 个的字符 U+0023（#）和一个 U+0022（双引号）字符。

原始字符串主体可以包含除 U+000D（CR）外的任意 Unicode 字符序列。它仅由另一个 U+0022（双引号）字符后跟与起始 U+0022（双引号）字符之前相同数量的 U+0023（#）字符来终止。

原始字符串主体中包含的所有 Unicode 字符都表示其自身，U+0022（双引号，当后跟至少与启动原始字符串字面量时所用相同数量的 U+0023（#）字符时除外）或 U+005C（\）没有任何特殊含义。

字符串字面量的示例：

#![allow(unused)]
fn main() {
"foo"; r"foo";                     // foo
"\"foo\""; r#""foo""#;             // "foo"

"foo #\"# bar";
r##"foo #"# bar"##;                // foo #"# bar

"\x52"; "R"; r"R";                 // R
"\\x52"; r"\x52";                  // \x52
}

字节与字节字符串字面量

字节字面量

字节字面量是一个单独的 ASCII 字符（在 U+0000 到 U+007F 范围内）或一个单独的转义，前置字符 U+0062（b）和 U+0027（单引号），后跟字符 U+0027。如果字面量中出现字符 U+0027，必须由前置的 U+005C（\）字符进行转义。它等价于一个 u8 无符号 8 位整数数字字面量。

字节字符串字面量

非原始字节字符串字面量是 ASCII 字符和转义的序列，前置字符 U+0062（b）和 U+0022（双引号），后跟字符 U+0022。如果字面量中出现字符 U+0022，必须由前置的 U+005C（\）字符进行转义。或者，字节字符串字面量也可以是原始字节字符串字面量，定义如下。

字节字符串字面量中允许换行，由字符 U+000A（LF）表示。字符 U+000D（CR）不能出现在字节字符串字面量中。当未转义的 U+005C 字符（\）紧接在换行之前出现时，该换行不会出现在 token 所表示的字符串中。详见字符串续行转义。

在字节字面量或非原始字节字符串字面量中，还可以使用一些额外的转义。转义以 U+005C（\）开头，并以下列形式之一继续：

• 字节转义转义以 U+0078（x）开头，后跟恰好两位十六进制数字。它表示与提供的十六进制值相等的字节。

• 空白转义是字符 U+006E（n）、U+0072（r）或 U+0074（t）之一，分别表示字节值 0x0A（ASCII LF）、0x0D（ASCII CR）或 0x09（ASCII HT）。

• 空转义是字符 U+0030（0），表示字节值 0x00（ASCII NUL）。

• 反斜杠转义是字符 U+005C（\），必须进行转义才能表示其 ASCII 编码 0x5C。

原始字节字符串字面量

原始字节字符串字面量不处理任何转义。它们以字符 U+0062（b）开头，后跟 U+0072（r），再后跟少于 256 个的字符 U+0023（#）和一个 U+0022（双引号）字符。

原始字符串主体可以包含除 U+000D（CR）外的任意 ASCII 字符序列。它仅由另一个 U+0022（双引号）字符后跟与起始 U+0022（双引号）字符之前相同数量的 U+0023（#）字符来终止。原始字节字符串字面量不能包含任何非 ASCII 字节。

原始字符串主体中包含的所有字符都表示其 ASCII 编码，U+0022（双引号，当后跟至少与启动原始字符串字面量时所用相同数量的 U+0023（#）字符时除外）或 U+005C（\）没有任何特殊含义。

字节字符串字面量的示例：

#![allow(unused)]
fn main() {
b"foo"; br"foo";                     // foo
b"\"foo\""; br#""foo""#;             // "foo"

b"foo #\"# bar";
br##"foo #"# bar"##;                 // foo #"# bar

b"\x52"; b"R"; br"R";                // R
b"\\x52"; br"\x52";                  // \x52
}

C 字符串与原始 C 字符串字面量

C 字符串字面量

C 字符串字面量是 Unicode 字符和转义的序列，前置字符 U+0063（c）和 U+0022（双引号），后跟字符 U+0022。如果字面量中出现字符 U+0022，必须由前置的 U+005C（\）字符进行转义。或者，C 字符串字面量也可以是原始 C 字符串字面量，定义如下。

C 字符串隐式地以字节 0x00 终止，因此 C 字符串字面量 c"" 等价于从字节字符串字面量 b"\x00" 手动构造一个 &CStr。除了隐式终止符外，C 字符串内不允许出现字节 0x00。

C 字符串字面量中允许换行，由字符 U+000A（LF）表示。字符 U+000D（CR）不能出现在 C 字符串字面量中。当未转义的 U+005C 字符（\）紧接在换行之前出现时，该换行不会出现在 token 所表示的字符串中。详见字符串续行转义。

在非原始 C 字符串字面量中，还可以使用一些额外的转义。转义以 U+005C（\）开头，并以下列形式之一继续：

• 字节转义转义以 U+0078（x）开头，后跟恰好两位十六进制数字。它表示与提供的十六进制值相等的字节。

• 24 位码点转义以 U+0075（u）开头，后跟最多六位十六进制数字，并用花括号 U+007B（{）和 U+007D（}）包围。它表示与提供的十六进制值相等的 Unicode 码点，以 UTF-8 编码。

• 空白转义是字符 U+006E（n）、U+0072（r）或 U+0074（t）之一，分别表示字节值 0x0A（ASCII LF）、0x0D（ASCII CR）或 0x09（ASCII HT）。

• 反斜杠转义是字符 U+005C（\），必须进行转义才能表示其 ASCII 编码 0x5C。

C 字符串表示没有定义编码的字节，但 C 字符串字面量可以包含 U+007F 以上的 Unicode 字符。这些字符将被替换为该字符 UTF-8 表示的字节。

以下 C 字符串字面量是等价的：

#![allow(unused)]
fn main() {
c"æ";        // 拉丁文小写字母 AE (U+00E6)
c"\u{00E6}";
c"\xC3\xA6";
}

原始 C 字符串字面量

原始 C 字符串字面量不处理任何转义。它们以字符 U+0063（c）开头，后跟 U+0072（r），再后跟少于 256 个的字符 U+0023（#）和一个 U+0022（双引号）字符。

原始 C 字符串主体可以包含除 U+0000（NUL）和 U+000D（CR）外的任意 Unicode 字符序列。它仅由另一个 U+0022（双引号）字符后跟与起始 U+0022（双引号）字符之前相同数量的 U+0023（#）字符来终止。

原始 C 字符串主体中包含的所有字符都以 UTF-8 编码表示其自身。U+0022（双引号，当后跟至少与启动原始 C 字符串字面量时所用相同数量的 U+0023（#）字符时除外）或 U+005C（\）没有任何特殊含义。

C 字符串与原始 C 字符串字面量的示例

#![allow(unused)]
fn main() {
c"foo"; cr"foo";                     // foo
c"\"foo\""; cr#""foo""#;             // "foo"

c"foo #\"# bar";
cr##"foo #"# bar"##;                 // foo #"# bar

c"\x52"; c"R"; cr"R";                // R
c"\\x52"; cr"\x52";                  // \x52
}

数字字面量

数字字面量可以是整数字面量或浮点数字面量。识别这两种字面量的语法是混合的。

整数字面量

整数字面量有以下四种形式：

• 十进制字面量以十进制数字开头，后续可以是十进制数字和下划线的任意混合。

• 十六进制字面量以字符序列 U+0030 U+0078（0x）开头，后续是十六进制数字和下划线的任意混合（至少一位数字）。

• 八进制字面量以字符序列 U+0030 U+006F（0o）开头，后续是八进制数字和下划线的任意混合（至少一位数字）。

• 二进制字面量以字符序列 U+0030 U+0062（0b）开头，后续是二进制数字和下划线的任意混合（至少一位数字）。

与所有字面量一样，整数字面量可以（紧接地，没有任何空格）后跟如上所述的后缀。后缀不能以 e 或 E 开头，因为这会被解释为浮点数字面量的指数。这些后缀的作用参见整数字面量表达式。

作为字面量表达式被接受的整数字面量示例：

#![allow(unused)]
fn main() {
#![allow(overflowing_literals)]
123;
123i32;
123u32;
123_u32;

0xff;
0xff_u8;
0x01_f32; // 整数 7986，而非浮点数 1.0
0x01_e3;  // 整数 483，而非浮点数 1000.0

0o70;
0o70_i16;

0b1111_1111_1001_0000;
0b1111_1111_1001_0000i64;
0b________1;

0usize;

// 这些超出了其类型范围，但作为字面量表达式仍被接受。
128_i8;
256_u8;

// 这是一个整数字面量，作为浮点数字面量表达式被接受。
5f32;
}

注意，例如 -1i8 会被分析为两个 token：- 后跟 1i8。

不被作为字面量表达式接受的整数字面量示例：

#![allow(unused)]
fn main() {
#[cfg(false)] {
0invalidSuffix;
123AFB43;
0b010a;
0xAB_CD_EF_GH;
0b1111_f32;
}
}

无效的整数字面量

某些整数字面量形式是无效的。为避免歧义，分词器会拒绝它们，而不是将其拆分为多个 token。

#![allow(unused)]
fn main() {
0b0102;  // 这不是 `0b010` 后跟 `2`。
0o1279;  // 这不是 `0o127` 后跟 `9`。
0x80.0;  // 这不是 `0x80` 后跟 `.` 和 `0`。
0b101e;  // 这不是带后缀的字面量或 `0b101` 后跟 `e`。
0b;      // 这不是整数字面量或 `0` 后跟 `b`。
0b_;     // 这不是整数字面量或 `0` 后跟 `b_`。
2em;     // 这不是带后缀的字面量或 `2` 后跟 `em`。
2.0em;   // 这不是带后缀的字面量或 `2.0` 后跟 `em`。
}

不带后缀的二进制或八进制字面量后紧跟其基数范围之外的十进制数字（中间没有空白字符）是错误的。

不带后缀的二进制、八进制或十六进制字面量后紧跟一个句点字符（中间没有空白字符）是错误的（受限于与浮点数字面量中关于句点后允许内容的相同限制）。

不带后缀的二进制或八进制字面量后紧跟字符 e 或 E（中间没有空白字符）是错误的。

基数前缀之后（在任何可选的前导下划线之后）没有至少一个有效的该进制数字是错误的。

元组索引

元组索引用于引用元组、元组结构体和元组枚举变体的字段。

元组索引直接与字面量 token 进行比较。元组索引以 0 开始，每个连续的索引以十进制值递增 1。因此，只有十进制值会匹配，且值不能有任何额外的前缀 0 字符。

元组索引不能包含任何后缀（如 usize）。

#![allow(unused)]
fn main() {
let example = ("dog", "cat", "horse");
let dog = example.0;
let cat = example.1;
// 以下示例是无效的。
let cat = example.01;  // ERROR 没有名为 `01` 的字段
let horse = example.0b10;  // ERROR 没有名为 `0b10` 的字段
let unicorn = example.0usize; // ERROR 元组索引上的后缀是无效的
let underscore = example.0_0; // ERROR 类型 `(&str, &str, &str)` 上没有字段 `0_0`
}

浮点数字面量

浮点数字面量有以下两种形式之一：

• 十进制字面量后跟句点字符 U+002E（.）。后可再跟另一个十进制字面量，以及可选的指数。
• 单个十进制字面量后跟指数。

与整数字面量类似，浮点数字面量可以后跟一个后缀，只要后缀之前的部分不以 U+002E（.）结尾。如果字面量不包含指数，后缀不能以 e 或 E 开头。这些后缀的作用参见浮点数字面量表达式。

作为字面量表达式被接受的浮点数字面量示例：

#![allow(unused)]
fn main() {
123.0f64;
0.1f64;
0.1f32;
12E+99_f64;
let x: f64 = 2.;
}

最后一个示例有所不同，因为不能在以句点结尾的浮点数字面量上使用后缀语法。2.f64 会尝试对 2 调用名为 f64 的方法。

注意，例如 -1.0 会被分析为两个 token：- 后跟 1.0。

不被作为字面量表达式接受的浮点数字面量示例：

#![allow(unused)]
fn main() {
#[cfg(false)] {
2.0f80;
2e5f80;
2e5e6;
2.0e5e6;
1.3e10u64;
}
}

浮点数字面量的指数没有数字是错误的。

#![allow(unused)]
fn main() {
2e;   // 这不是浮点数字面量或 `2` 后跟 `e`。
2.0e; // 这不是浮点数字面量或 `2.0` 后跟 `e`。
}

生命周期与循环标签

生命周期参数和循环标签使用 LIFETIME_OR_LABEL token。任何 LIFETIME_TOKEN 都会被词法分析器接受，例如可以用于宏中。

原始生命周期类似于普通生命周期，但其标识符带有 r# 前缀。（注意，r# 前缀不算作实际生命周期的一部分。）

与普通生命周期不同，原始生命周期可以使用任何严格或保留关键字，但上述 RAW_LIFETIME 所列的除外。

使用 RESERVED_RAW_LIFETIME token 是错误的。

标点符号

标点符号 token 用作运算符、分隔符以及语法的其他组成部分。

定界符

括号标点用于语法的各个部分。开放括号必须始终与闭合括号配对。括号及其内部的 token 在宏中被称为“token 树“。三种括号类型如下：

保留 token

几种 token 形式保留供将来使用或为避免混淆。源代码输入匹配这些形式之一是错误的。

保留前缀

某些词法形式（称为保留前缀）保留供将来使用。

原本会被词法解释为非原始标识符（或关键字）且紧接后跟 #、' 或 " 字符（中间没有空白字符）的源代码输入将被识别为保留前缀。

注意，原始标识符、原始字符串字面量和原始字节字符串字面量可以包含 # 字符，但不会被解释为包含保留前缀。

类似地，用于原始字符串字面量、字节字面量、字节字符串字面量、原始字节字符串字面量、C 字符串字面量和原始 C 字符串字面量的 r、b、br、c 和 cr 前缀不会被解释为保留前缀。

原本会被词法解释为非原始生命周期（或关键字）且紧接后跟 # 字符（中间没有空白字符）的源代码输入将被识别为保留生命周期前缀。

保留守卫

保留守卫是为将来使用而保留的语法，使用时会产生编译错误。

保留守卫字符串字面量是一个由一个或多个 U+0023（#）后紧跟 STRING_LITERAL 组成的 token。

保留井号是一个由两个或多个 U+0023（#）组成的 token。

1. 同一直面量两侧的 # 数量必须相等。 ↩

2. 所有数字字面量都允许 _ 作为视觉分隔符：1_234.0E+18f64 ↩

3. 参见 lex.token.literal.char-escape.unicode。 ↩

宏

Rust 的功能和语法可以通过称为宏的自定义定义来扩展。它们被赋予名称，并通过一致的语法来调用：some_extension!(...)。

有两种定义新宏的方式：

• 声明宏以高阶的、声明式的方式定义新语法。
• 过程宏使用操作输入 token 的函数来定义类函数宏、自定义派生宏和自定义属性宏。

宏调用

宏调用在编译时展开宏，并用宏的结果替换调用。宏可以在以下情况下调用：

• 表达式与语句

• 模式

• 类型

• 项（包括关联项）

• macro_rules 转写器

• 外部块

当作为项或语句使用时，对于不使用花括号的情况，应使用 MacroInvocationSemi 形式，在末尾需要有一个分号。在宏调用或 macro_rules 定义之前绝不允许出现可见性限定符。

#![allow(unused)]
fn main() {
// 作为表达式使用。
let x = vec![1,2,3];

// 作为语句使用。
println!("Hello!");

// 在模式中使用。
macro_rules! pat {
    ($i:ident) => (Some($i))
}

if let pat!(x) = Some(1) {
    assert_eq!(x, 1);
}

// 在类型中使用。
macro_rules! Tuple {
    { $A:ty, $B:ty } => { ($A, $B) };
}

type N2 = Tuple!(i32, i32);

// 作为程序项使用。
use std::cell::RefCell;
thread_local!(static FOO: RefCell<u32> = RefCell::new(1));

// 作为关联程序项使用。
macro_rules! const_maker {
    ($t:ty, $v:tt) => { const CONST: $t = $v; };
}
trait T {
    const_maker!{i32, 7}
}

// 宏中嵌套宏调用。
macro_rules! example {
    () => { println!("Macro call in a macro!") };
}
// 外层宏 `example` 先展开，然后内层宏 `println` 展开。
example!();
}

宏调用可以通过两种作用域来解析：

• 文本作用域
  • 文本作用域 macro_rules
• 基于路径的作用域
  • 基于路径的作用域 macro_rules
  • 过程宏

声明宏