#[doc(keyword = "as")]
//
/// 在类型之间进行转换，或重命名导入。
///
/// `as` 最常用于将基本类型转换为其他基本类型，但它还有其他用途，包括将指针转换为地址、将地址转换为指针以及将指针转换为其他指针。
///
/// ```rust
/// let thing1: u8 = 89.0 as u8;
/// assert_eq!('B' as u32, 66);
/// assert_eq!(thing1 as char, 'Y');
/// let thing2: f32 = thing1 as f32 + 10.5;
/// assert_eq!(true as u8 + thing2 as u8, 100);
/// ```
///
/// 通常，任何可以通过指定类型执行的强制转换也可以使用 `as` 完成，因此，除了编写 `let x: u32 = 123` 之外，您还可以编写 `let x = 123 as u32` (注意: 在这种情况下，`let x: u32 = 123` 最好)。
/// 但是，在另一个方向上并非如此。
/// 显式使用 `as` 可以允许更多隐式不允许的强制，例如更改裸指针的类型或将闭包转换为裸指针。
///
/// `as` 可以看作是 `From` 和 `Into` 的原语: `as` 仅适用于原语 (`u8`，`bool`，`str`，指针等)，而 `From` 和 `Into` 也适用于 `String` 或 `Vec` 等类型。
///
/// `as` 当可以推断目标类型时，也可以与 `_` 占位符一起使用。请注意，这可能会导致推理中断，通常，此类代码应使用显式类型以确保清晰度和稳定性。
/// 使用 `as *const _` 或 `as* mut _` 转换指针时，这是最有用的，尽管 `as *const _` 推荐使用 [`cast`][const-cast] 方法，而 `as* mut _` 则建议使用 [the same][mut-cast]: 这些方法使意图更清晰。
///
///
/// `as` 还用于重命名 [`use`] 和 [`extern crate`][`crate`] 语句中的导入:
///
/// ```
/// # #[allow(unused_imports)]
/// use std::{mem as memory, net as network};
/// // 现在，您可以使用名称 `memory` 和 `network` 来引用 `std::mem` 和 `std::net`。
/// ```
/// 有关 `as` 的功能的更多信息，请参见 [Reference]。
///
/// [Reference]: ../reference/expressions/operator-expr.html#type-cast-expressions
/// [`crate`]: keyword.crate.html
/// [`use`]: keyword.use.html
/// [const-cast]: pointer::cast
/// [mut-cast]: primitive.pointer.html#method.cast-1
///
///
///
///
///
///
///
///
mod as_keyword {}

#[doc(keyword = "break")]
//
/// 从循环中提前退出。
///
/// 遇到 `break` 时，将立即终止关联循环体的执行。
///
/// ```rust
/// let mut last = 0;
///
/// for x in 1..100 {
///     if x > 12 {
///         break;
///     }
///     last = x;
/// }
///
/// assert_eq!(last, 12);
/// println!("{}", last);
/// ```
///
/// break 表达式通常与包围 `break` 的最里面的循环相关联，但是可以使用标签来指定哪个包围循环受到影响。
///
///
/// ```rust
/// 'outer: for i in 1..=5 {
///     println!("outer iteration (i): {}", i);
///
///     '_inner: for j in 1..=200 {
///         println!("    inner iteration (j): {}", j);
///         if j >= 3 {
///             // 从内循环中断，让外循环继续。
///             break;
///         }
///         if i >= 2 {
///             // 从外部循环中断，并直接到达 "Bye"。
///             break 'outer;
///         }
///     }
/// }
/// println!("Bye.");
/// ```
///
/// 与 `loop` 关联时，可以使用 break 表达式从该循环返回一个值。
/// 这仅对 `loop` 有效，对其他任何类型的循环均无效。
/// 如果未指定任何值，则 `break;` 返回 `()`。
/// 循环中的每个 `break` 必须返回相同的类型。
///
/// ```rust
/// let (mut a, mut b) = (1, 1);
/// let result = loop {
///     if b > 10 {
///         break b;
///     }
///     let c = a + b;
///     a = b;
///     b = c;
/// };
/// // 斐波纳契数列中第一个超过 10 的数字:
/// assert_eq!(result, 13);
/// println!("{}", result);
/// ```
///
/// 有关更多详细信息，请咨询 [Reference on "break expression"] 和 [Reference on "break and loop values"]。
///
/// [Reference on "break expression"]: ../reference/expressions/loop-expr.html#break-expressions
/// [Reference on "break and loop values"]:
/// ../reference/expressions/loop-expr.html#break-and-loop-values
///
///
mod break_keyword {}

#[doc(keyword = "const")]
//
/// 编译时常量和编译时可评估函数。
///
/// ## 编译时常量
///
/// 有时，某个值在整个程序中会多次使用，并且一遍又一遍地复制它会变得很不方便。
/// 而且，使其成为每个需要它的函数的变量并非总是可能或不希望的。
/// 在这些情况下，`const` 关键字为代码复制提供了一种方便的替代方法:
///
/// ```rust
/// const THING: u32 = 0xABAD1DEA;
///
/// let foo = 123 + THING;
/// ```
///
/// 常量必须显式地输入。与 `let` 不同，您不能忽略它们的类型并让编译器确定它的类型。
/// 可以在 `const` 中定义任何常量值，而实际上 `const` 恰好是大多数在常量中合理的东西 (除非使用 const fn`s)。
///
/// 例如，您不能将 [`File`] 作为 `const`。
///
/// [`File`]: crate::fs::File
///
/// 常量中唯一允许的生命周期是 `'static`，它是 Rust 程序中包含所有其他生命周期的生命周期。
/// 例如，如果您想定义一个常量字符串，它将看起来像这样:
///
/// ```rust
/// const WORDS: &'static str = "hello rust!";
/// ```
///
/// 多亏了静态生命周期省略，您通常不必显式使用 `'static`:
///
/// ```rust
/// const WORDS: &str = "hello convenience!";
/// ```
///
/// `const` 该项看起来与 `static` 项非常相似，后者在何时应使用哪个引起了一些混淆。
/// 简而言之，常量在任何使用它们的地方都被内联，使用它们与简单地用它的值替换 `const` 的名称是相同的。
/// 另一方面，静态变量指向内存中所有访问共享的单个位置。
/// 这意味着，与常量不同，它们不能具有析构函数，并且在整个代码库中都可以充当单个值。
///
/// 常量 (如静态变量) 应始终位于 `SCREAMING_SNAKE_CASE` 中。
///
/// 有关 `const` 的更多详细信息，请参见 [Rust Book] 或 [Reference]。
///
/// ## 编译时可评估函数
///
/// `const` 关键字的另一个主要用途是在 `const fn` 中。
/// 这将一个函数标记为可以在 `const` 或 `static` 项的主体中以及在数组初始化程序 (通常称为 "const contexts") 中被调用。
/// `const fn` 限制它们可以执行的一组操作，以确保可以在编译时对其进行评估。
/// 有关更多详细信息，请参见 [Reference][const-eval]。
///
/// 将 `fn` 转换为 `const fn` 对该函数的运行时使用没有影响。
///
/// ## `const` 的其他用途
///
/// `const` 关键字也与 `mut` 一起用于裸指针中，如 `*const T` 和 `* mut T` 所示。
/// 可以在 [指针原语][pointer primitive] 的 Rust 文档中阅读有关裸指针中使用的 `const` 的更多信息。
///
/// [pointer primitive]: pointer
/// [Rust Book]: ../book/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants
/// [Reference]: ../reference/items/constant-items.html
/// [const-eval]: ../reference/const_eval.html
///
///
///
///
///
mod const_keyword {}

#[doc(keyword = "continue")]
//
/// 跳到循环的下一个迭代。
///
/// 遇到 `continue` 时，当前迭代终止，将控制权返回到循环头，通常继续进行下一个迭代。
///
///
/// ```rust
/// // 通过跳过偶数来打印奇数
/// for number in 1..=10 {
///     if number % 2 == 0 {
///         continue;
///     }
///     println!("{}", number);
/// }
/// ```
///
/// 与 `break` 一样，`continue` 通常与最里面的循环相关联，但是可以使用标签来指定受影响的循环。
///
/// ```rust
/// // 使用单元 <= 5 打印 30 以下的奇数
/// 'tens: for ten in 0..3 {
///     '_units: for unit in 0..=9 {
///         if unit % 2 == 0 {
///             continue;
///         }
///         if unit > 5 {
///             continue 'tens;
///         }
///         println!("{}", ten * 10 + unit);
///     }
/// }
/// ```
///
/// 有关更多详细信息，请参见参考中的 [continue 表达式][continue expressions]。
///
/// [continue expressions]: ../reference/expressions/loop-expr.html#continue-expressions
///
mod continue_keyword {}

#[doc(keyword = "crate")]
//
/// Rust 二进制或库。
///
/// `crate` 关键字的主要用途是 `extern crate` 声明的一部分，该声明用于指定对 crate 的依赖，该依赖在其声明的外部。
///
/// Crates 是 Rust 代码的基本编译单元，可以看作是库或项目。
/// 可以在 [Reference] 中了解有关 crates 的更多信息。
///
/// ```rust ignore
/// extern crate rand;
/// extern crate my_crate as thing;
/// extern crate std; // 隐式添加到每个 Rust 项目的根目录
/// ```
///
/// `as` 关键字可用于更改 crate 在您的项目中的含义。
/// 如果 crate 名称包含破折号，则将其隐式导入，并用下划线代替破折号。
///
/// `crate` 也可以与 `pub` 一起使用，以表示它所附加的项仅对它所在的同一 crate 的其他成员是公共的。
///
/// ```rust
/// # #[allow(unused_imports)]
/// pub(crate) use std::io::Error as IoError;
/// pub(crate) enum CoolMarkerType { }
/// pub struct PublicThing {
///     pub(crate) semi_secret_thing: bool,
/// }
/// ```
///
/// `crate` 也用于表示模块的绝对路径，其中 `crate` 指向当前 crate 的根。
/// 例如，`crate::foo::bar` 在同一 crate 中的任何其他位置引用模块 `foo` 内部的名称 `bar`。
///
/// [Reference]: ../reference/items/extern-crates.html
///
///
mod crate_keyword {}

#[doc(keyword = "else")]
//
/// [`if`] 条件评估为 [`false`] 时要评估的表达式。
///
/// `else` 表达式是可选的。如果未提供其他表达式，则假定计算结果为单元类型 `()`。
///
/// `else` 块求值的类型必须与 `if` 块求值的类型兼容。
///
/// 如下所示，`else` 后面必须是: `if`，`if let` 或块 `{}`，它将返回该表达式的值。
///
/// ```rust
/// let result = if true == false {
///     "oh no"
/// } else if "something" == "other thing" {
///     "oh dear"
/// } else if let Some(200) = "blarg".parse::<i32>().ok() {
///     "uh oh"
/// } else {
///     println!("Sneaky side effect.");
///     "phew, nothing's broken"
/// };
/// ```
///
/// 这是另一个示例，但是在这里我们不尝试返回表达式:
///
/// ```rust
/// if true == false {
///     println!("oh no");
/// } else if "something" == "other thing" {
///     println!("oh dear");
/// } else if let Some(200) = "blarg".parse::<i32>().ok() {
///     println!("uh oh");
/// } else {
///     println!("phew, nothing's broken");
/// }
/// ```
///
/// 上面是 _still_ 的表达式，但它将始终为 `()`。
///
/// 跟随 `if` 表达式的 `else` 块的数量可能没有限制，但是，如果有多个，则最好使用 [`match`] 表达式。
///
///
/// 在 [Rust 书][Rust Book] 中阅读更多关于控制流的信息。
///
/// [Rust Book]: ../book/ch03-05-control-flow.html#handling-multiple-conditions-with-else-if
/// [`match`]: keyword.match.html
/// [`false`]: keyword.false.html
/// [`if`]: keyword.if.html
///
///
///
mod else_keyword {}

#[doc(keyword = "enum")]
//
/// 可以是几个成员中任何一个的类型。
///
/// Rust 中的枚举与其他编译语言 (如 C) 相似，但有一些重要区别，使它们的功能更加强大。
/// 如果您来自函数式编程背景，那么 Rust 所谓的枚举通常被称为 [代数数据类型][ADT]。
/// 重要的细节是每个枚举成员都可以拥有数据。
///
/// ```rust
/// # struct Coord;
/// enum SimpleEnum {
///     FirstVariant,
///     SecondVariant,
///     ThirdVariant,
/// }
///
/// enum Location {
///     Unknown,
///     Anonymous,
///     Known(Coord),
/// }
///
/// enum ComplexEnum {
///     Nothing,
///     Something(u32),
///     LotsOfThings {
///         usual_struct_stuff: bool,
///         blah: String,
///     }
/// }
///
/// enum EmptyEnum { }
/// ```
///
/// 显示的第一个枚举是在 C 风格语言中常见的一种枚举。
/// 第二个示例展示了一个存储位置数据的假设示例，其中 `Coord` 是需要的任何其他类型，例如结构体。
/// 第三个示例演示了成员可以存储的数据类型，从无到有，到元组，再到匿名结构体。
///
/// 实例化枚举成员涉及显式地使用枚举的名称作为它的命名空间，后跟一个成员。
/// `SimpleEnum::SecondVariant` 从上面是一个例子。
/// 当数据跟一个成员一起使用时，例如 rust 的内置 [`Option`] 类型，该数据将按类型描述添加，例如 `Option::Some(123)`。
///
/// 类似于结构体的成员也是如此，类似 ` ComplexEnum::LotsOfThings {通常 _struct_stuff:
/// true, blah: "hello!".to_string(), }`.
/// 空枚举与 [`!`] 相似，因为它们根本无法实例化，并且主要用于以有趣的方式弄乱类型系统。
///
/// 有关更多信息，请查看 [Rust Book] 或 [Reference]
///
/// [ADT]: https://en.wikipedia.org/wiki/Algebraic_data_type
/// [Rust Book]: ../book/ch06-01-defining-an-enum.html
/// [Reference]: ../reference/items/enumerations.html
///
///
mod enum_keyword {}

#[doc(keyword = "extern")]
//
/// 链接到或导入外部代码。
///
/// `extern` 关键字在 Rust 中的两个位置使用。
/// 一种是与 [`crate`] 关键字结合使用，以使您的 Rust 代码了解项目中的其他 Rust crates，即， `extern crate lazy_static;`.
/// 另一个用途是在外部函数接口 (FFI) 中。
///
/// `extern` 在 FFI 中用于两个不同的上下文。
/// 第一种是外部块的形式，用于声明 Rust 代码可以调用外部代码的函数接口。
///
/// ```rust ignore
/// #[link(name = "my_c_library")]
/// extern "C" {
///     fn my_c_function(x: i32) -> bool;
/// }
/// ```
///
/// 该代码将在运行时尝试与类 Unix 系统上的 `libmy_c_library.so` 和 Windows 上的 `my_c_library.dll` 链接，如果找不到要链接的内容，则尝试与 panic 链接。
///
/// 然后，Rust 代码可以使用 `my_c_function`，就好像它是其他任何不安全的 Rust 函数一样。
/// 使用非 Rust 语言和 FFI 本质上是不安全的，因此包装程序通常围绕 C API 构建。
///
/// FFI 的镜像用例也通过 `extern` 关键字完成:
///
/// ```rust
/// #[no_mangle]
/// pub extern "C" fn callable_from_c(x: i32) -> bool {
///     x % 3 == 0
/// }
/// ```
///
/// 如果编译为 dylib，则可以将 C00 库链接到生成的 .so，并且可以像使用任何其他库一样使用该函数。
///
/// 有关 FFI 的更多信息，请检查 [Rust book] 或 [Reference]。
///
/// [Rust book]:
/// ../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
/// [Reference]: ../reference/items/external-blocks.html
/// [`crate`]: keyword.crate.html
///
mod extern_keyword {}

#[doc(keyword = "false")]
//
/// [`bool`] 类型的值，表示逻辑 **false**。
///
/// `false` 与 [`true`] 逻辑相反。
///
/// 有关更多信息，请参见 [`true`] 的文档。
///
/// [`true`]: keyword.true.html
mod false_keyword {}

#[doc(keyword = "fn")]
//
/// 一个函数或函数指针。
///
/// 函数是在 Rust 中执行代码的主要方式。通常称为函数的函数块可以在各种不同的位置定义，并分配有许多不同的属性和修饰符。
///
/// 仅位于未附加任何模块的模块中的独立函数是常见的，但是大多数函数最终将最终位于 [`impl`] 块中，或者位于另一种类型本身上，或者作为该类型的 trait 隐式实现。
///
///
/// ```rust
/// fn standalone_function() {
///     // code
/// }
///
/// pub fn public_thing(argument: bool) -> String {
///     // code
///     # "".to_string()
/// }
///
/// struct Thing {
///     foo: i32,
/// }
///
/// impl Thing {
///     pub fn new() -> Self {
///         Self {
///             foo: 42,
///         }
///     }
/// }
/// ```
///
/// 除了以 `fn name(arg: type, ..) -> return_type` 形式显示固定类型外，函数还可以声明类型参数列表以及它们所属的 trait bounds。
///
/// ```rust
/// fn generic_function<T: Clone>(x: T) -> (T, T, T) {
///     (x.clone(), x.clone(), x.clone())
/// }
///
/// fn generic_where<T>(x: T) -> T
///     where T: std::ops::Add<Output = T> + Copy
/// {
///     x + x + x
/// }
/// ```
///
/// 在尖括号中声明 trait bounds 在功能上与使用 `where` 子句相同。
/// 由程序员决定在每种情况下哪种效果更好，但是当事情长于一行时，`where` 往往会更好。
///
/// 除了通过 `pub` 公开之外，`fn` 还可以添加 [`extern`] 以用于 FFI。
///
/// 有关各种类型的函数以及如何使用它们的更多信息，请查阅 [Rust book] 或 [Reference]。
///
/// [`impl`]: keyword.impl.html
/// [`extern`]: keyword.extern.html
/// [Rust book]: ../book/ch03-03-how-functions-work.html
/// [Reference]: ../reference/items/functions.html
///
///
///
///
///
///
///
///
mod fn_keyword {}

#[doc(keyword = "for")]
//
/// 使用 [`in`] 进行迭代，使用 [`impl`] 或 [higher-ranked trait bounds] (`for<'a>`) 实现 trait。
///
/// `for` 关键字在许多语法位置中使用:
///
/// * `for` 用于循环中 (请参见下文)。
/// * `for` 如在 `impl Trait for Type` 中实现 traits 时使用 (有关此信息，请参见 [`impl`])。
/// * `for` 与 `for<'a> &'a T: PartialEq<i32>` 一样，也用于 [higher-ranked trait bounds]。
///
/// for-in 循环，或更确切地说，是迭代器循环，是 Rust 中一种常见实践上的简单语法糖，它遍历所有实现 [`IntoIterator`] 的对象，直到 `.into_iter()` 返回的迭代器返回 `None` (或循环体使用 `break`)。
///
///
/// ```rust
/// for i in 0..5 {
///     println!("{}", i * 2);
/// }
///
/// for i in std::iter::repeat(5) {
///     println!("turns out {} never stops being 5", i);
///     break; // 否则将永远循环
/// }
///
/// 'outer: for x in 5..50 {
///     for y in 0..10 {
///         if x == y {
///             break 'outer;
///         }
///     }
/// }
/// ```
///
/// 如上面的示例所示，可以使用与生命周期相似的语法 (仅在视觉上相似，实际上完全不同) 来标记 `for` 循环 (以及所有其他循环)。给 `break` 提供相同的标记会中断标记的循环，这对于内部循环很有用。
/// 绝对不是 goto。
///
/// `for` 循环如下图所示展开:
///
/// ```rust
/// # fn code() { }
/// # let iterator = 0..2;
/// for loop_variable in iterator {
///     code()
/// }
/// ```
///
/// ```rust
/// # fn code() { }
/// # let iterator = 0..2;
/// {
///     let result = match IntoIterator::into_iter(iterator) {
///         mut iter => loop {
///             let next;
///             match iter.next() {
///                 Some(val) => next = val,
///                 None => break,
///             };
///             let loop_variable = next;
///             let () = { code(); };
///         },
///     };
///     result
/// }
/// ```
///
/// 有关所显示功能的更多详细信息，请参见 [`IntoIterator`] 文档。
///
/// 有关 for 循环的更多信息，请参见 [Rust book] 或 [Reference]。
///
/// 另请参见 [`loop`]， [`while`].
///
/// [`in`]: keyword.in.html
/// [`impl`]: keyword.impl.html
/// [`loop`]: keyword.loop.html
/// [`while`]: keyword.while.html
/// [higher-ranked trait bounds]: ../reference/trait-bounds.html#higher-ranked-trait-bounds
/// [Rust book]:
/// ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
/// [Reference]: ../reference/expressions/loop-expr.html#iterator-loops
///
///
///
///
///
mod for_keyword {}

#[doc(keyword = "if")]
//
/// 如果条件成立，则评估一个块。
///
/// `if` 是大多数程序员熟悉的结构，并且是您经常在代码中执行逻辑的主要方式。
/// 但是，与大多数语言不同，`if` 块也可以充当表达式。
///
/// ```rust
/// # let rude = true;
/// if 1 == 2 {
///     println!("whoops, mathematics broke");
/// } else {
///     println!("everything's fine!");
/// }
///
/// let greeting = if rude {
///     "sup nerd."
/// } else {
///     "hello, friend!"
/// };
///
/// if let Ok(x) = "123".parse::<i32>() {
///     println!("{} double that and you get {}!", greeting, x * 2);
/// }
/// ```
///
/// 上面显示的是 `if` 块的三种典型形式。
/// 首先是带有多种 `else` 块的多种语言中常见的事物。
/// 第二种使用 `if` 作为表达式，仅当所有分支都返回相同类型时才有可能。
/// `if` 表达式可以在您期望的任何地方使用。
/// 第三种 `if` 块是 `if let` 块，其行为类似于使用 `match` 表达式:
///
/// ```rust
/// if let Some(x) = Some(123) {
///     // code
///     # let _ = x;
/// } else {
///     // 其他的东西
/// }
///
/// match Some(123) {
///     Some(x) => {
///         // code
///         # let _ = x;
///     },
///     _ => {
///         // 其他的东西
///     },
/// }
/// ```
///
/// 每种 `if` 表达式都可以根据需要进行混合和匹配。
///
/// ```rust
/// if true == false {
///     println!("oh no");
/// } else if "something" == "other thing" {
///     println!("oh dear");
/// } else if let Some(200) = "blarg".parse::<i32>().ok() {
///     println!("uh oh");
/// } else {
///     println!("phew, nothing's broken");
/// }
/// ```
///
/// `if` 关键字在 Rust 中的另一个位置使用，即作为样式匹配自身的一部分，从而允许使用诸如 `Some(x) if x > 200` 的样式。
///
///
/// 有关 `if` 表达式的更多信息，请参见 [Rust book] 或 [Reference]。
///
/// [Rust book]: ../book/ch03-05-control-flow.html#if-expressions
/// [Reference]: ../reference/expressions/if-expr.html
mod if_keyword {}

#[doc(keyword = "impl")]
//
/// 为类型实现一些功能。
///
/// `impl` 关键字主要用于定义类型的实现。
/// 固有实现是独立的，而 trait 实现则用于为类型或其他 traits 实现 traits。
///
/// 函数和 const 都可以在实现中定义。`impl` 块中定义的函数可以是独立的，这意味着将其称为 `Foo::bar()`。
/// 如果该函数将 `self`，`&self` 或 `&mut self` 作为它的第一个参数，则也可以使用方法调用语法来调用它，这是任何面向 object 的程序员 (如 `foo.bar()`) 都熟悉的功能。
///
///
/// ```rust
/// struct Example {
///     number: i32,
/// }
///
/// impl Example {
///     fn boo() {
///         println!("boo! Example::boo() was called!");
///     }
///
///     fn answer(&mut self) {
///         self.number += 42;
///     }
///
///     fn get_number(&self) -> i32 {
///         self.number
///     }
/// }
///
/// trait Thingy {
///     fn do_thingy(&self);
/// }
///
/// impl Thingy for Example {
///     fn do_thingy(&self) {
///         println!("doing a thing! also, number is {}!", self.number);
///     }
/// }
/// ```
///
/// 有关实现的更多信息，请参见 [Rust book][book1] 或 [Reference]。
///
/// `impl` 关键字的另一个用法是 `impl Trait` 语法，可以将其视为 "a concrete type that implements this trait" 的简写。
/// 它的主要用途是与闭包一起使用，闭包具有在编译时生成的类型定义，不能简单地将其键入。
///
/// ```rust
/// fn thing_returning_closure() -> impl Fn(i32) -> bool {
///     println!("here's a closure for you!");
///     |x: i32| x % 3 == 0
/// }
/// ```
///
/// 有关 `impl Trait` 语法的更多信息，请参见 [Rust book][book2]。
///
/// [book1]: ../book/ch05-03-method-syntax.html
/// [Reference]: ../reference/items/implementations.html
/// [book2]: ../book/ch10-02-traits.html#returning-types-that-implement-traits
///
///
///
mod impl_keyword {}

#[doc(keyword = "in")]
//
/// 使用 [`for`] 迭代一系列值。
///
/// `in` 之后的表达式必须实现 [`IntoIterator`] trait。
///
/// ## 字面量示例:
///
///    * `for _ in 1..3 {}` - 迭代一个唯一的范围，但不超过 3。
///    * `for _ in 1..=3 {}` - 迭代包含 3 的范围 (包括 3)。
///
/// (了解有关 [range patterns] 的更多信息)
///
/// [`IntoIterator`]: ../book/ch13-04-performance.html
/// [range patterns]: ../reference/patterns.html?highlight=range#range-patterns
/// [`for`]: keyword.for.html
mod in_keyword {}

#[doc(keyword = "let")]
//
/// 将值绑定到变量。
///
/// `let` 关键字的主要用途是在 `let` 语句中，该语句用于将一组新变量引入到当前的作用域中，如模式所示。
///
///
/// ```rust
/// # #![allow(unused_assignments)]
/// let thing1: i32 = 100;
/// let thing2 = 200 + thing1;
///
/// let mut changing_thing = true;
/// changing_thing = false;
///
/// let (part1, part2) = ("first", "second");
///
/// struct Example {
///     a: bool,
///     b: u64,
/// }
///
/// let Example { a, b: _ } = Example {
///     a: true,
///     b: 10004,
/// };
/// assert!(a);
/// ```
///
/// 模式通常是单个变量，这意味着不进行模式匹配，并且给定的表达式已绑定到该变量。
/// 除此之外，鉴于 `let` 绑定是详尽无遗的，因此可以根据需要将其复杂化。
/// 有关模式匹配的更多信息，请参见 [Rust book][book1]。
/// 以后可以选择提供模式的类型，但是如果可能的话，编译器会自动推断出是否留空。
///
/// Rust 中的变量默认情况下是不可变的，并且要求将 `mut` 关键字设置为可变。
///
/// 可以使用相同的名称定义多个变量，称为阴影。
/// 除了无法在阴影点之外直接访问它之外，这不会以任何方式影响原始变量。
/// 它继续保留在作用域中，只有在它离开离开作用域时才被丢弃。
/// 带阴影的变量不需要与带阴影的变量具有相同的类型。
///
/// ```rust
/// let shadowing_example = true;
/// let shadowing_example = 123.4;
/// let shadowing_example = shadowing_example as u32;
/// let mut shadowing_example = format!("cool! {}", shadowing_example);
/// shadowing_example += " something else!"; // 不遮蔽
/// ```
///
/// `let` 关键字使用的其他位置包括 `if let` 表达式形式的 [`if`]。
/// 如果匹配的模式不是穷举的 (例如枚举)，则它们很有用。
/// `while let` 也存在，它使用模式匹配值运行循环，直到该模式无法匹配为止。
///
/// 有关 `let` 关键字的更多信息，请参见 [Rust book][book2] 或 [Reference]。
///
/// [book1]: ../book/ch06-02-match.html
/// [`if`]: keyword.if.html
/// [book2]: ../book/ch18-01-all-the-places-for-patterns.html#let-statements
/// [Reference]: ../reference/statements.html#let-statements
///
///
mod let_keyword {}

#[doc(keyword = "while")]
//
/// 保持条件时循环播放。
///
/// `while` 表达式用于谓词循环。
/// `while` 表达式在运行循环主体之前先运行条件表达式，然后在条件表达式的计算结果为 `true` 时运行循环主体，否则退出循环。
///
///
/// ```rust
/// let mut counter = 0;
///
/// while counter < 10 {
///     println!("{}", counter);
///     counter += 1;
/// }
/// ```
///
/// 像 [`for`] 表达式一样，我们可以使用 `break` 和 `continue`。`while` 表达式不能用值中断，并且总是与 [`loop`] 不同而求值为 `()`。
///
/// ```rust
/// let mut i = 1;
///
/// while i < 100 {
///     i *= 2;
///     if i == 64 {
///         break; // `i` 为 64 时退出。
///     }
/// }
/// ```
///
/// 由于 `if` 表达式在 `if let` 中具有其模式匹配成员，因此 `while` 表达式与 `while let` 也是如此。
/// `while let` 表达式将模式与该表达式进行匹配，如果模式匹配成功，则运行循环主体，否则退出循环。
/// 就像在 `while` 中一样，我们可以在 `while let` 表达式中使用 `break` 和 `continue`。
///
/// ```rust
/// let mut counter = Some(0);
///
/// while let Some(i) = counter {
///     if i == 10 {
///         counter = None;
///     } else {
///         println!("{}", i);
///         counter = Some (i + 1);
///     }
/// }
/// ```
///
/// 有关 `while` 和常规循环的更多信息，请参见 [reference]。
///
/// 另请参见 [`for`]， [`loop`].
///
/// [`for`]: keyword.for.html
/// [`loop`]: keyword.loop.html
/// [reference]: ../reference/expressions/loop-expr.html#predicate-loops
///
///
mod while_keyword {}

#[doc(keyword = "loop")]
//
/// 无限循环。
///
/// `loop` 用于定义 Rust 支持的最简单的循环类型。
/// 它在其中运行代码，直到代码使用 `break` 或程序退出为止。
///
/// ```rust
/// loop {
///     println!("hello world forever!");
///     # break;
/// }
///
/// let mut i = 1;
/// loop {
///     println!("i is {}", i);
///     if i > 100 {
///         break;
///     }
///     i *= 2;
/// }
/// assert_eq!(i, 128);
/// ```
///
/// 与 Rust 中的其他类型的循环 (`while`，`while let` 和 `for`) 不同，循环可以用作通过 `break` 返回值的表达式。
///
///
/// ```rust
/// let mut i = 1;
/// let something = loop {
///     i *= 2;
///     if i > 100 {
///         break i;
///     }
/// };
/// assert_eq!(something, 128);
/// ```
///
/// 循环中的每个 `break` 必须具有相同的类型。
/// 如果未明确给出任何内容，则 `break;` 返回 `()`。
///
/// 有关 `loop` 和常规循环的更多信息，请参见 [Reference]。
///
/// 另请参见 [`for`]， [`while`].
///
/// [`for`]: keyword.for.html
/// [`while`]: keyword.while.html
/// [Reference]: ../reference/expressions/loop-expr.html
mod loop_keyword {}

#[doc(keyword = "match")]
//
/// 基于模式匹配的控制流。
///
/// `match` 可用于有条件地运行代码。
/// 必须显式或通过使用通配符 (例如 `match` 中的 `_`) 来详尽地处理每个模式。
///
/// 由于 `match` 是表达式，因此也可以返回值。
///
/// ```rust
/// let opt = Option::None::<usize>;
/// let x = match opt {
///     Some(int) => int,
///     None => 10,
/// };
/// assert_eq!(x, 10);
///
/// let a_number = Option::Some(10);
/// match a_number {
///     Some(x) if x <= 5 => println!("0 to 5 num = {}", x),
///     Some(x @ 6..=10) => println!("6 to 10 num = {}", x),
///     None => panic!(),
///     // 所有其他数字
///     _ => panic!(),
/// }
/// ```
///
/// `match` 可以用来获取枚举的内部成员并直接使用它们。
///
/// ```rust
/// enum Outer {
///     Double(Option<u8>, Option<String>),
///     Single(Option<u8>),
///     Empty
/// }
///
/// let get_inner = Outer::Double(None, Some(String::new()));
/// match get_inner {
///     Outer::Double(None, Some(st)) => println!("{}", st),
///     Outer::Single(opt) => println!("{:?}", opt),
///     _ => panic!(),
/// }
/// ```
///
/// 有关 `match` 和常规匹配的更多信息，请参见 [Reference]。
///
/// [Reference]: ../reference/expressions/match-expr.html
///
mod match_keyword {}

#[doc(keyword = "mod")]
//
/// 将代码整理到 [模块][modules] 中。
///
/// 使用 `mod` 创建新的 [模块][modules] 来封装代码，包括其他模块:
///
/// ```
/// mod foo {
///     mod bar {
///         type MyType = (u8, u8);
///         fn baz() {}
///     }
/// }
/// ```
///
/// 像 [`struct`] 和 [`enum`] 一样，模块及其内容默认是私有的，模块外部的代码无法访问。
///
///
/// 要了解有关允许访问的更多信息，请参见 [`pub`] 关键字的文档。
///
/// [`enum`]: keyword.enum.html
/// [`pub`]: keyword.pub.html
/// [`struct`]: keyword.struct.html
/// [modules]: ../reference/items/modules.html
///
///
mod mod_keyword {}

#[doc(keyword = "move")]
//
/// 按值捕获 [闭包][closure] 的环境。
///
/// `move` 将任何通过引用捕获的变量转换为通过引用捕获的变量。
///
/// ```rust
/// let data = vec![1, 2, 3];
/// let closure = move || println!("captured {:?} by value", data);
///
/// // 数据不再可用，它由闭包拥有
/// ```
///
/// Note: 即使 `move` 闭包通过 `move` 捕获变量，它们仍然可以实现 [`Fn`] 或 [`FnMut`]。
/// 这是因为由闭包类型实现的 traits 是由闭包对捕获的值进行的操作 (而不是对捕获值的方式) 确定的:
///
///
/// ```rust
/// fn create_fn() -> impl Fn() {
///     let text = "Fn".to_owned();
///     move || println!("This is a: {}", text)
/// }
///
/// let fn_plain = create_fn();
/// fn_plain();
/// ```
///
/// `move` 涉及 [线程][threads] 时经常使用。
///
/// ```rust
/// let data = vec![1, 2, 3];
///
/// std::thread::spawn(move || {
///     println!("captured {:?} by value", data)
/// }).join().unwrap();
///
/// // 数据被移动到衍生线程，所以我们不能在这里使用它
/// ```
///
/// `move` 在异步块之前也有效。
///
/// ```rust
/// let capture = "hello".to_owned();
/// let block = async move {
///     println!("rust says {} from async block", capture);
/// };
/// ```
///
/// 有关 `move` 关键字的更多信息，请参见 Rust 书籍的 [闭包][closure] 部分或 [线程][threads] 部分。
///
/// [closure]: ../book/ch13-01-closures.html
/// [threads]: ../book/ch16-01-threads.html#using-move-closures-with-threads
///
///
///
mod move_keyword {}

#[doc(keyword = "mut")]
//
/// 可变变量，引用或指针。
///
/// `mut` 可以在几种情况下使用。
/// 第一个是变量变量，它可以在可以将值绑定到变量名称的任何地方使用。一些例子:
///
/// ```rust
/// // 函数的参数列表中的可变变量。
/// fn foo(mut x: u8, y: u8) -> u8 {
///     x += y;
///     x
/// }
///
/// // 修改可变变量。
/// # #[allow(unused_assignments)]
/// let mut a = 5;
/// a = 6;
///
/// assert_eq!(foo(3, 4), 7);
/// assert_eq!(a, 6);
/// ```
///
/// 第二个是可变引用。
/// 它们可以从 `mut` 变量创建，并且必须唯一: 其他变量不能具有变量引用，也不能具有共享引用。
///
///
/// ```rust
/// // 采取可变引用。
/// fn push_two(v: &mut Vec<u8>) {
///     v.push(2);
/// }
///
/// // 可变引用不能用于非可变变量。
/// let mut v = vec![0, 1];
/// // 通过可变引用。
/// push_two(&mut v);
///
/// assert_eq!(v, vec![0, 1, 2]);
/// ```
///
/// ```rust,compile_fail,E0502
/// let mut v = vec![0, 1];
/// let mut_ref_v = &mut v;
/// ##[allow(unused)]
/// let ref_v = &v;
/// mut_ref_v.push(2);
/// ```
///
/// 可变裸指针的工作方式与可变引用非常相似，但有可能无法指向有效的 object。
/// 语法为 `*mut Type`。
///
/// 可以在 [Reference] 中找到更多关于资源 0 引用和指针的信息。
///
/// [Reference]: ../reference/types/pointer.html#mutable-references-mut
///
mod mut_keyword {}

#[doc(keyword = "pub")]
//
/// 使一个项目对其他人可见。
///
/// 关键字 `pub` 使得可以从外部模块内部访问任何模块，函数或数据结构体。
/// `pub` 关键字也可以在 `use` 声明中使用，以重命名名称空间中的标识符。
///
/// 有关 `pub` 关键字的更多信息，请参见 [reference] 的可见性部分，有关某些示例，请参见 [Rust 示例][Rust by Example]。
///
///
/// [reference]:../reference/visibility-and-privacy.html?highlight=pub#visibility-and-privacy
/// [Rust by Example]:../rust-by-example/mod/visibility.html
///
mod pub_keyword {}

#[doc(keyword = "ref")]
//
/// 在模式匹配期间由引用绑定。
///
/// `ref` 注解模式绑定，使它们借用而不是移动。
/// 就匹配而言，它不是模式的一部分: 不影响 *是否* 匹配值，仅 *如何* 匹配。
///
/// 默认情况下，当您实际上不需要移动和拥有值时，[`match`] 语句将尽一切可能使用，这有时可能是个问题:
///
///
/// ```compile_fail,E0382
/// let maybe_name = Some(String::from("Alice"));
/// // 变量 'maybe_name' 在这里使用...
/// match maybe_name {
///     Some(n) => println!("Hello, {}", n),
///     _ => println!("Hello, world"),
/// }
/// // ... 现在不可用。
/// println!("Hello again, {}", maybe_name.unwrap_or("world".into()));
/// ```
///
/// 使用 `ref` 关键字，该值仅被借用，而不移动，从而使它可在 [`match`] 语句之后使用:
///
/// ```
/// let maybe_name = Some(String::from("Alice"));
/// // 使用 `ref`，该值是借用的，而不是移动的...
/// match maybe_name {
///     Some(ref n) => println!("Hello, {}", n),
///     _ => println!("Hello, world"),
/// }
/// // ... 所以可以在这里!
/// println!("Hello again, {}", maybe_name.unwrap_or("world".into()));
/// ```
///
/// # `&` vs `ref`
///
/// - `&` 表示您的模式需要 object 的引用。
/// 因此，`&` 是所述模式的一部分: `&Foo` 与 `Foo` 匹配不同的对象。
///
/// - `ref` 表示您希望对未包装的值进行引用。不匹配: `Foo(ref foo)` 与 `Foo(foo)` 匹配相同的对象。
///
/// 有关更多信息，请参见 [Reference]。
///
/// [`match`]: keyword.match.html
/// [Reference]: ../reference/patterns.html#identifier-patterns
///
///
///
mod ref_keyword {}

#[doc(keyword = "return")]
//
/// 从函数返回值。
///
/// `return` 在函数中标记执行路径的结尾:
///
/// ```
/// fn foo() -> i32 {
///     return 3;
/// }
/// assert_eq!(foo(), 3);
/// ```
///
/// `return` 当返回值是函数中的最后一个表达式时，则不需要。
/// 在这种情况下，将省略 `;`:
///
/// ```
/// fn foo() -> i32 {
///     3
/// }
/// assert_eq!(foo(), 3);
/// ```
///
/// `return` 立即从函数 ("early return") 返回:
///
/// ```no_run
/// use std::fs::File;
/// use std::io::{Error, ErrorKind, Read, Result};
///
/// fn main() -> Result<()> {
///     let mut file = match File::open("foo.txt") {
///         Ok(f) => f,
///         Err(e) => return Err(e),
///     };
///
///     let mut contents = String::new();
///     let size = match file.read_to_string(&mut contents) {
///         Ok(s) => s,
///         Err(e) => return Err(e),
///     };
///
///     if contents.contains("impossible!") {
///         return Err(Error::new(ErrorKind::Other, "oh no!"));
///     }
///
///     if size > 9000 {
///         return Err(Error::new(ErrorKind::Other, "over 9000!"));
///     }
///
///     assert_eq!(contents, "Hello, world!");
///     Ok(())
/// }
/// ```
mod return_keyword {}

#[doc(keyword = "self")]
//
/// 方法的接收者，或当前模块。
///
/// `self` 在两种情况下使用: 引用当前模块和标记方法的接收者。
///
/// 在路径中，`self` 可用于在 [`use`] 语句中或在访问元素的路径中引用当前模块:
///
///
/// ```
/// # #![allow(unused_imports)]
/// use std::io::{self, Read};
/// ```
///
/// 在功能上与以下内容相同:
///
/// ```
/// # #![allow(unused_imports)]
/// use std::io;
/// use std::io::Read;
/// ```
///
/// 使用 `self` 访问当前模块中的元素:
///
/// ```
/// # #![allow(dead_code)]
/// # fn main() {}
/// fn foo() {}
/// fn bar() {
///     self::foo()
/// }
/// ```
///
/// `self` 因为当前方法的接收者允许大部分时间省略参数类型。
/// 除了这种特殊性，`self` 的用法与任何其他参数非常相似:
///
/// ```
/// struct Foo(i32);
///
/// impl Foo {
///     // 没有 `self`。
///     fn new() -> Self {
///         Self(0)
///     }
///
///     // 消耗 `self`。
///     fn consume(self) -> Self {
///         Self(self.0 + 1)
///     }
///
///     // 借用 `self`。
///     fn borrow(&self) -> &i32 {
///         &self.0
///     }
///
///     // 借用 `self` 可变。
///     fn borrow_mut(&mut self) -> &mut i32 {
///         &mut self.0
///     }
/// }
///
/// // 必须使用 `Type::` 前缀调用此方法。
/// let foo = Foo::new();
/// assert_eq!(foo.0, 0);
///
/// // 这两个调用产生相同的结果。
/// let foo = Foo::consume(foo);
/// assert_eq!(foo.0, 1);
/// let foo = foo.consume();
/// assert_eq!(foo.0, 2);
///
/// // 使用第二种语法会自动处理借用。
/// let borrow_1 = Foo::borrow(&foo);
/// let borrow_2 = foo.borrow();
/// assert_eq!(borrow_1, borrow_2);
///
/// // 第二种语法也会自动处理可变借用。
/// let mut foo = Foo::new();
/// *Foo::borrow_mut(&mut foo) += 1;
/// assert_eq!(foo.0, 1);
/// *foo.borrow_mut() += 1;
/// assert_eq!(foo.0, 2);
/// ```
///
/// 请注意，调用 `foo.method()` 时的这种自动转换不限于以上示例。
/// 有关更多信息，请参见 [Reference]。
///
/// [`use`]: keyword.use.html
/// [Reference]: ../reference/items/associated-items.html#methods
///
///
mod self_keyword {}

// FIXME: 一旦 rustdoc 可以处理不区分大小写的文件系统上的 URL 冲突，我们就可以删除下三行并放回去: `#[doc(keyword = "Self")]`.
//
#[doc(alias = "Self")]
#[allow(rustc::existing_doc_keyword)]
#[doc(keyword = "SelfTy")]
//
/// [`trait`] 或 [`impl`] 块中的实现类型，或类型定义中的当前类型。
///
///
/// 在类型定义内:
///
/// ```
/// # #![allow(dead_code)]
/// struct Node {
///     elem: i32,
///     // `Self` 这里是 `Node`。
///     next: Option<Box<Self>>,
/// }
/// ```
///
/// 在 [`impl`] 块中:
///
/// ```
/// struct Foo(i32);
///
/// impl Foo {
///     fn new() -> Self {
///         Self(0)
///     }
/// }
///
/// assert_eq!(Foo::new().0, Foo(0).0);
/// ```
///
/// `Self` 隐含了泛型参数:
///
/// ```
/// # #![allow(dead_code)]
/// struct Wrap<T> {
///     elem: T,
/// }
///
/// impl<T> Wrap<T> {
///     fn new(elem: T) -> Self {
///         Self { elem }
///     }
/// }
/// ```
///
/// 在 [`trait`] 定义和相关的 [`impl`] 块中:
///
/// ```
/// trait Example {
///     fn example() -> Self;
/// }
///
/// struct Foo(i32);
///
/// impl Example for Foo {
///     fn example() -> Self {
///         Self(42)
///     }
/// }
///
/// assert_eq!(Foo::example().0, Foo(42).0);
/// ```
///
/// [`impl`]: keyword.impl.html
/// [`trait`]: keyword.trait.html
mod self_upper_keyword {}

#[doc(keyword = "static")]
//
/// 静态项是在程序的整个持续时间 (`'static` 生命周期) 内有效的值。
///
/// 从表面上看，`static` 项与 [`const`] 非常相似: 两者都包含一个值，都需要类型注解，并且都只能使用常量函数和值进行初始化。
///
/// 但是，`static` 与众不同之处在于它们表示内存中的一个位置。
/// 这意味着您可以引用 `static` 项，甚至可以对其进行修改，从而使它们本质上是变量。
///
/// 静态项不要在程序末尾调用 [`drop`]。
///
/// `static` 项有两种类型: 与 [`mut`] 关键字关联声明的 `static` 项和没有 [`mut`] 关键字的 `static` 项。
///
/// 静态项无法移动:
///
/// ```rust,compile_fail,E0507
/// static VEC: Vec<u32> = vec![];
///
/// fn move_vec(v: Vec<u32>) -> Vec<u32> {
///     v
/// }
///
/// // 该行导致错误
/// move_vec(VEC);
/// ```
///
/// # 简单的 `static`
///
/// 访问非 [`mut`] `static` 项被认为是安全的，但存在一些限制。
/// 最值得注意的是，`static` 值的类型需要实现 [`Sync`] trait，排除内部可变性容器 (如 [`RefCell`])。
/// 有关更多信息，请参见 [Reference]。
///
/// ```rust
/// static FOO: [i32; 5] = [1, 2, 3, 4, 5];
///
/// let r1 = &FOO as *const _;
/// let r2 = &FOO as *const _;
/// // 对于严格只读的静态，引用将具有相同的地址
/// assert_eq!(r1, r2);
/// // 在许多情况下，可以像使用变量一样使用静态项
/// println!("{:?}", FOO);
/// ```
///
/// # 可变 `static`
///
/// 如果使用 [`mut`] 关键字声明了 `static` 项，则程序允许对其进行修改。
/// 但是，访问可变的 `static` 可能以多种方式导致未定义的行为，例如由于多线程上下文中的数据竞争。
/// 因此，对可变 `static` 的所有访问都需要一个 [`unsafe`] 块。
///
/// 尽管它们不安全，但是在许多情况下，可变的 static 是必需的:
/// 它们可用于表示整个程序共享的状态或在 [`extern`] 块中绑定到 C 库中的变量。
///
/// 在 [`extern`] 块中:
///
/// ```rust,no_run
/// # #![allow(dead_code)]
/// extern "C" {
///     static mut ERROR_MESSAGE: *mut std::os::raw::c_char;
/// }
/// ```
///
/// 就像简单的静态变量一样，可变静态变量也有一些限制。有关更多信息，请参见 [Reference]。
///
/// [`const`]: keyword.const.html
/// [`extern`]: keyword.extern.html
/// [`mut`]: keyword.mut.html
/// [`unsafe`]: keyword.unsafe.html
/// [`RefCell`]: cell::RefCell
/// [Reference]: ../reference/items/static-items.html
///
///
///
///
///
///
///
///
///
mod static_keyword {}

#[doc(keyword = "struct")]
//
/// 由其他类型组成的类型。
///
/// Rust 中的结构体有三种风格: 带有命名字段的结构体，元组结构体和单元结构体。
///
/// ```rust
/// struct Regular {
///     field1: f32,
///     field2: String,
///     pub field3: bool
/// }
///
/// struct Tuple(u32, String);
///
/// struct Unit;
/// ```
///
/// 常规结构体是最常用的。它们中定义的每个字段都有一个名称和类型，一旦定义，就可以使用 `example_struct.field` 语法进行访问。
/// 结构体的字段共享其可变性，因此 `foo.bar = 2;` 仅在 `foo` 是可变的时才有效。
/// 在字段中添加 `pub` 使其可以在其他模块中的代码中看到，并且可以直接对其进行访问和修改。
///
/// 元组结构体与常规结构体相似，但其字段没有名称。它们像元组一样使用，可以通过 `let TupleStruct(x, y) = foo;` 语法进行解构。
/// 为了访问单个变量，使用与常规元组相同的语法，即 `foo.0`，`foo.1` 等，从零开始。
///
/// 单元结构体最常用作标记。它们的大小为零字节，但是与空的枚举不同，它们可以实例化，使其与单元类型 `()` 同构。
/// 当您需要在某物上实现 trait 而不需要在其中存储任何数据时，单元结构体非常有用。
///
/// # Instantiation
///
/// 可以用不同的方式实例化结构体，所有方式都可以根据需要进行混合和匹配。
/// 生成新结构体的最常见方法是通过诸如 `new()` 之类的构造函数方法，但是当该方法不可用 (或者您正在编写构造函数本身) 时，将使用结构体字面量语法:
///
/// ```rust
/// # struct Foo { field1: f32, field2: String, etc: bool }
/// let example = Foo {
///     field1: 42.0,
///     field2: "blah".to_string(),
///     etc: true,
/// };
/// ```
///
/// 当您对结构体的所有字段都可见时，才可以使用结构体字面量语法直接实例化结构体。
///
/// 提供了一些快捷方式，以使编写构造函数更加方便，其中最常见的是缩写词初始化简写语法。
/// 当变量和字段具有相同的名称时，可以将分配从 `field: field` 简化为 `field`。
/// 假设的构造函数的以下示例说明了这一点:
///
/// ```rust
/// struct User {
///     name: String,
///     admin: bool,
/// }
///
/// impl User {
///     pub fn new(name: String) -> Self {
///         Self {
///             name,
///             admin: false,
///         }
///     }
/// }
/// ```
///
/// 结构体实例化的另一种快捷方式是可用的，当您需要制作一个具有与大多数以前相同类型的结构体相同的值的新结构体时，可以使用该快捷方式，称为结构体更新语法:
///
///
/// ```rust
/// # struct Foo { field1: String, field2: () }
/// # let thing = Foo { field1: "".to_string(), field2: () };
/// let updated_thing = Foo {
///     field1: "a new value".to_string(),
///     ..thing
/// };
/// ```
///
/// 元组结构体以与元组本身相同的方式实例化，不同之处在于结构体的名称为前缀: `Foo(123, false, 0.1)`.
///
/// 空结构体仅用其名称实例化，不需要其他任何东西。`let thing =
/// EmptyStruct;`
///
/// # 样式约定
///
/// 结构体总是用骆驼命名法编写的，只有少数例外。
/// 虽然可以省略结构体的字段列表中的结尾逗号，但为了方便在行中添加和删除字段，通常将其保留下来。
///
/// 有关结构体的更多信息，请查看 [Rust 书][book] 或 [reference]。
///
/// [`PhantomData`]: marker::PhantomData
/// [book]: ../book/ch05-01-defining-structs.html
/// [reference]: ../reference/items/structs.html
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
mod struct_keyword {}

#[doc(keyword = "super")]
//
/// 当前 [模块][module] 的父级。
///
/// ```rust
/// # #![allow(dead_code)]
/// # fn main() {}
/// mod a {
///     pub fn foo() {}
/// }
/// mod b {
///     pub fn foo() {
///         super::a::foo(); // 调用 a 的 foo 函数
///     }
/// }
/// ```
///
/// 也可以多次使用 `super`: `super::super::foo`，在祖先链上进行。
///
///
/// 有关更多信息，请参见 [Reference]。
///
/// [module]: ../reference/items/modules.html
/// [Reference]: ../reference/paths.html#super
mod super_keyword {}

#[doc(keyword = "trait")]
//
/// 一组类型的通用接口。
///
/// `trait` 就像数据类型可以实现的接口。当类型实现 trait 时，可以使用泛型或 trait 对象抽象地将其视为 trait。
///
/// Traits 可以由三个关联项组成:
///
/// - 函数和方法
/// - types
/// - constants
///
/// Traits 也可能包含其他类型参数。这些类型参数或 trait 本身可以受到其他 traits 的约束。
///
/// Traits 可以用作标记或承载其他逻辑语义，这些逻辑语义不是通过其项表示的。
/// 当一个类型实现该 trait 时，它承诺遵守其契约。
/// [`Send`] [`Sync`] 和 [`Sync`] 是标准库中存在的两个此类标记 traits。
///
/// 有关 traits 的更多信息，请参见 [Reference][Ref-Traits]。
///
/// # Examples
///
/// Traits 使用 `trait` 关键字声明。类型可以使用 [`impl`] `Trait` [`for`] `Type` 来实现它们:
///
/// ```rust
/// trait Zero {
///     const ZERO: Self;
///     fn is_zero(&self) -> bool;
/// }
///
/// impl Zero for i32 {
///     const ZERO: Self = 0;
///
///     fn is_zero(&self) -> bool {
///         *self == Self::ZERO
///     }
/// }
///
/// assert_eq!(i32::ZERO, 0);
/// assert!(i32::ZERO.is_zero());
/// assert!(!4.is_zero());
/// ```
///
/// 带有关联类型:
///
/// ```rust
/// trait Builder {
///     type Built;
///
///     fn build(&self) -> Self::Built;
/// }
/// ```
///
/// Traits 可以是泛型，有约束或无约束:
///
/// ```rust
/// trait MaybeFrom<T> {
///     fn maybe_from(value: T) -> Option<Self>
///     where
///         Self: Sized;
/// }
/// ```
///
/// Traits 可以建立在其他 traits 的需求之上。在下面的示例中，`Iterator` 是 **supertrait**，而 `ThreeIterator` 是 **subtrait**:
///
/// ```rust
/// trait ThreeIterator: std::iter::Iterator {
///     fn next_three(&mut self) -> Option<[Self::Item; 3]>;
/// }
/// ```
///
/// Traits 可以在函数中用作参数:
///
/// ```rust
/// # #![allow(dead_code)]
/// fn debug_iter<I: Iterator>(it: I) where I::Item: std::fmt::Debug {
///     for elem in it {
///         println!("{:#?}", elem);
///     }
/// }
///
/// // u8_len_1，u8_len_2 和 u8_len_3 是等效的
///
/// fn u8_len_1(val: impl Into<Vec<u8>>) -> usize {
///     val.into().len()
/// }
///
/// fn u8_len_2<T: Into<Vec<u8>>>(val: T) -> usize {
///     val.into().len()
/// }
///
/// fn u8_len_3<T>(val: T) -> usize
/// where
///     T: Into<Vec<u8>>,
/// {
///     val.into().len()
/// }
/// ```
///
/// 或作为返回类型:
///
/// ```rust
/// # #![allow(dead_code)]
/// fn from_zero_to(v: u8) -> impl Iterator<Item = u8> {
///     (0..v).into_iter()
/// }
/// ```
///
/// 在该位置使用 [`impl`] 关键字，函数 writer 可以将具体类型隐藏为实现细节，可以在不破坏用户代码的情况下对其进行更改。
///
///
/// # Trait 对象
///
/// *trait 对象* 是另一种实现一组 traits 的不透明值。trait object 实现所有指定的 traits 及其上级特征 (如果有)。
///
/// 语法如下: `dyn BaseTrait + AutoTrait1 + ... AutoTraitN`.
/// 只能使用一个 `BaseTrait`，因此无法编译:
///
/// ```rust,compile_fail,E0225
/// trait A {}
/// trait B {}
///
/// let _: Box<dyn A + B>;
/// ```
///
/// 这也不是，这是语法错误:
///
/// ```rust,compile_fail
/// trait A {}
/// trait B {}
///
/// let _: Box<dyn A + dyn B>;
/// ```
///
/// 另一方面，这是正确的:
///
/// ```rust
/// trait A {}
///
/// let _: Box<dyn A + Send + Sync>;
/// ```
///
/// [Reference][Ref-Trait-Objects] 具有有关 trait 对象，它们的限制以及版本之间的差异的更多信息。
///
/// # 不安全的 traits
///
/// 某些 traits 可能不安全实现。在 trait 声明的前面使用 [`unsafe`] 关键字进行标记:
///
/// ```rust
/// unsafe trait UnsafeTrait {}
///
/// unsafe impl UnsafeTrait for i32 {}
/// ```
///
/// # 2015 年版和 2018 年版之间的差异
///
/// 在 2015 版中，traits 不需要参数模式:
///
/// ```rust,edition2015
/// # #![allow(anonymous_parameters)]
/// trait Tr {
///     fn f(i32);
/// }
/// ```
///
/// 此行为在 2018 版中不再有效。
///
/// [`for`]: keyword.for.html
/// [`impl`]: keyword.impl.html
/// [`unsafe`]: keyword.unsafe.html
/// [Ref-Traits]: ../reference/items/traits.html
/// [Ref-Trait-Objects]: ../reference/types/trait-object.html
///
///
///
///
///
///
///
///
///
///
///
mod trait_keyword {}

#[doc(keyword = "true")]
//
/// [`bool`] 类型的值，表示逻辑 `true`。
///
/// 逻辑上 `true` 不等于 [`false`]。
///
/// ## 检查 **true** 的控制结构
///
/// Rust 的几个控制结构将检查 `bool` 条件是否评估为 `true`。
///
///   * [`if`] 表达式中的条件必须为 `bool` 类型。
///     只要该条件评估为 `true`，`if` 表达式就会采用第一个块的值。
///     但是，如果条件计算结果为 `false`，则表达式为 `else` 块的值 (如果有)。
///
///
///   * [`while`] 是另一个控制流构造，期望使用 `bool` 类型的条件。
///     只要条件评估为 `true`，`while` 循环将连续评估其关联的块。
///
///   * [`match`] 分支上可以有保护子句。
///
/// [`if`]: keyword.if.html
/// [`while`]: keyword.while.html
/// [`match`]: ../reference/expressions/match-expr.html#match-guards
/// [`false`]: keyword.false.html
///
mod true_keyword {}

#[doc(keyword = "type")]
//
/// 为现有类型定义别名。
///
/// 语法为 `type Name = ExistingType;`。
///
/// # Examples
///
/// `type` 不创建新类型:
///
/// ```rust
/// type Meters = u32;
/// type Kilograms = u32;
///
/// let m: Meters = 3;
/// let k: Kilograms = 3;
///
/// assert_eq!(m, k);
/// ```
///
/// 在 traits 中，`type` 用于声明 [associated type]:
///
/// ```rust
/// trait Iterator {
///     // 关联类型声明
///     type Item;
///     fn next(&mut self) -> Option<Self::Item>;
/// }
///
/// struct Once<T>(Option<T>);
///
/// impl<T> Iterator for Once<T> {
///     // 关联类型定义
///     type Item = T;
///     fn next(&mut self) -> Option<Self::Item> {
///         self.0.take()
///     }
/// }
/// ```
///
/// [`trait`]: keyword.trait.html
/// [associated type]: ../reference/items/associated-items.html#associated-types
mod type_keyword {}

#[doc(keyword = "unsafe")]
//
/// [memory safety] 不能由类型系统验证的代码或接口。
///
/// `unsafe` 关键字有两个用途: 声明编译器无法检查的契约的存在 (`unsafe fn` 和 `unsafe trait`)，以及声明程序员检查了这些契约是否得到遵守 (`unsafe {}` 和 `unsafe impl`，还有 `unsafe fn` - 见下文)。
///
/// 它们并不互斥，如 `unsafe fn` 所示。
///
/// # 不安全能力
///
/// **无论如何，安全 Rust 都不会导致未定义行为**。这称为 [soundness]: 类型正确的程序实际上具有所需的属性。[Nomicon][nomicon-soundness] 对此主题有更详细的说明。
///
/// 为了确保安全，Safe Rust 受到足够的限制，可以自动检查。但是，有时出于某些原因，需要编写正确的代码，而这些原因对于编译器来说太聪明了。在这种情况下，您需要使用不安全的 Rust。
///
/// 除安全 Rust 之外，以下还有不安全 Rust 所具有的功能:
///
/// - 解引用 [raw pointers]
/// - 实现 `unsafe` [`trait`]
/// - 调用 `unsafe` 函数
/// - 可变的 [`static`] (包括 [`extern`] al 个)
/// - [`union`] 的访问字段
///
/// 但是，这种额外的权力还伴随着额外的责任: 现在要确保声音的完整性。`unsafe` 关键字有助于明确标记需要担心的代码段。
///
/// ## `unsafe` 的不同含义
///
/// 并非 `unsafe` 的所有用法都是等效的: 这里有些标记是程序员必须检查的契约的存在，而另一些是 "I have checked the contract, go ahead and do this"。
/// 以下 [discussion on Rust Internals] 对此有更深入的说明，但这是要点的总结:
///
/// - `unsafe fn`: 调用此函数意味着遵守编译器无法强制执行的契约。
/// - `unsafe trait`: 实现 [`trait`] 意味着遵守编译器无法执行的契约。
/// - `unsafe {}`: 程序员已检查了在块中进行操作所必需的契约，并保证该契约得到遵守。
/// - `unsafe impl`: 程序员已经检查了实现 trait 所需的契约，并保证该契约得到遵守。
///
/// `unsafe fn` 在函数内的代码周围，它也像一个 `unsafe {}` 块。这意味着不仅要向调用者发出信号，而且还应 promises 维护函数内部操作的前提条件。
/// 混合使用这两种含义可能会造成混淆，并且存在在进行 `unsafe` 操作时在此类函数中使用 `unsafe {}` 块的建议。
///
/// 有关更多信息，请参见 [Rustnomicon] 和 [Reference]。
///
/// # Examples
///
/// ## 标记元素为 `unsafe`
///
/// `unsafe` 可以在函数上使用。请注意，在 [`extern`] 块中声明的函数和静态变量被隐式标记为 `unsafe` (但未被声明为 `extern "something" fn ...` 的函数)。
/// 无论在何处声明，可变静态变量始终是不安全的。方法也可以声明为 `unsafe`:
///
/// ```rust
/// # #![allow(dead_code)]
/// static mut FOO: &str = "hello";
///
/// unsafe fn unsafe_fn() {}
///
/// extern "C" {
///     fn unsafe_extern_fn();
///     static BAR: *mut u32;
/// }
///
/// trait SafeTraitWithUnsafeMethod {
///     unsafe fn unsafe_method(&self);
/// }
///
/// struct S;
///
/// impl S {
///     unsafe fn unsafe_method_on_struct() {}
/// }
/// ```
///
/// Traits 也可以声明为 `unsafe`:
///
/// ```rust
/// unsafe trait UnsafeTrait {}
/// ```
///
/// 由于 `unsafe fn` 和 `unsafe trait` 表示存在编译器无法强制执行的安全保证，因此对其进行记录很重要。标准库提供了许多示例，例如以下示例，它是 [`Vec::set_len`] 的摘录。
/// `# Safety` 部分说明了安全调用函数必须履行的契约。
///
/// ```rust,ignore (stub-to-show-doc-example)
/// /// 将 vector 的长度强制为 `new_len`。
//////
/// /// 这是一个维操作，不保留该类型的任何普通不变式。
/// /// 通常，使用安全操作之一 (例如 `truncate`，`resize`，`extend` 或 `clear`) 来更改 vector 的长度。
//////
//////
/// /// # Safety
//////
/// /// - `new_len` 必须小于或等于 `capacity()`。
/// /// - `old_len..new_len` 上的元素必须初始化。
//////
/// pub unsafe fn set_len(&mut self, new_len: usize)
/// ```
///
/// ## 使用 `unsafe {}` 块和 `impl`s
///
/// 执行 `unsafe` 操作需要一个 `unsafe {}` 块:
///
/// ```rust
/// # #![allow(dead_code)]
/// /// 解引用给定的指针。
//////
/// /// # Safety
//////
/// /// `ptr` 必须对齐并且不能悬空。
/// unsafe fn deref_unchecked(ptr: *const i32) -> i32 {
///     *ptr
/// }
///
/// let a = 3;
/// let b = &a as *const _;
/// // SAFETY: `a` 尚未丢弃，并且引用始终对齐，因此 `b` 是有效地址。
/////
/// unsafe { assert_eq!(*b, deref_unchecked(b)); };
/// ```
///
/// 标记为 `unsafe` 的 Traits 必须使用 `unsafe impl` 进行复制。这为实现满足 trait 的安全保证的其他 `unsafe` 代码提供了保证。[Send] 和 [Sync] traits 是标准库中此行为的示例。
///
/// ```rust
/// /// trait 的实现者必须保证元素始终可以通过索引 3 访问。
//////
/// unsafe trait ThreeIndexable<T> {
///     /// 返回 `&self` 中索引为 3 的元素的引用。
///     fn three(&self) -> &T;
/// }
///
/// // `[T; 4]` 的 `ThreeIndexable` 实现是 `unsafe`，因为实现者必须遵守编译器无法检查的契约，但作为一名程序员，我们知道在索引 3 处总会有一个有效元素要访问。
/////
/////
/////
/// unsafe impl<T> ThreeIndexable<T> for [T; 4] {
///     fn three(&self) -> &T {
///         // SAFETY: 实现 trait 意味着总是有一个索引为 3 的元素可以访问。
/////
///         unsafe { self.get_unchecked(3) }
///     }
/// }
///
/// let a = [1, 2, 4, 8];
/// assert_eq!(a.three(), &8);
/// ```
///
/// [`extern`]: keyword.extern.html
/// [`trait`]: keyword.trait.html
/// [`static`]: keyword.static.html
/// [`union`]: keyword.union.html
/// [`impl`]: keyword.impl.html
/// [raw pointers]: ../reference/types/pointer.html
/// [memory safety]: ../book/ch19-01-unsafe-rust.html
/// [Rustnomicon]: ../nomicon/index.html
/// [nomicon-soundness]: ../nomicon/safe-unsafe-meaning.html
/// [soundness]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#soundness-of-code--of-a-library
/// [Reference]: ../reference/unsafety.html
/// [proposal]: https://github.com/rust-lang/rfcs/pull/2585
/// [discussion on Rust Internals]: https://internals.rust-lang.org/t/what-does-unsafe-mean/6696
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
mod unsafe_keyword {}

#[doc(keyword = "use")]
//
/// 从其他 crates 或模块导入或重命名项。
///
/// 通常，使用 `use` 关键字来缩短引用模块项所需的路径。
/// 关键字可能出现在模块，块甚至函数中，通常在顶部。
///
/// 关键字最基本的用法是 `use path::to::item;`，尽管支持许多便捷的快捷方式:
///
///   * 使用类似 glob 的大括号语法 `use a::b::{c, d, e::f, g::h::i};` 同时绑定具有公共前缀的路径列表
///   * 使用 [`self`] 关键字 (例如 `use a::b::{self, c, d::e};`) 同时绑定具有公共前缀的路径列表及其公共父模块
///
///   * 使用语法 `use p::q::r as x;` 将目标名称重新绑定为新的本地名称。
///     这也可以与最后两个功能一起使用: `use a::b::{self as ab, c as abc}`.
///   * 使用星号通配符语法 `use a::b::*;` 绑定与给定前缀匹配的所有路径。
///   * 多次嵌套先前功能的组，例如 `use a::b::{self as ab, c, d::{*, e::f}};`
///   * 使用可见性修改器 (例如 `pub use a::b;`) 进行重导出
///   * 使用 `_` 导入仅导入 trait 的方法而不将其绑定到名称 (例如，避免冲突) : `use ::std::io::Read as _;`.
///
/// 支持使用 [`crate`]，[`super`] 或 [`self`] 之类的路径限定符: `use crate::a::b;`.
///
/// 注意，当在类型上使用通配符 `*` 时，它不会导入其方法 (尽管对于 `enum` 而言，它会导入成员，如下例所示)。
///
/// ```compile_fail,edition2018
/// enum ExampleEnum {
///     VariantA,
///     VariantB,
/// }
///
/// impl ExampleEnum {
///     fn new() -> Self {
///         Self::VariantA
///     }
/// }
///
/// use ExampleEnum::*;
///
/// // Compiles.
/// let _ = VariantA;
///
/// // 不编译!
/// let n = new();
/// ```
///
/// 有关 `use` 和常规路径的更多信息，请参见 [Reference]。
///
/// 也可以在 [Reference] 中找到有关 2015 年版本和 2018 年版本之间的路径和 `use` 关键字的差异。
///
/// [`crate`]: keyword.crate.html
/// [`self`]: keyword.self.html
/// [`super`]: keyword.super.html
/// [Reference]: ../reference/items/use-declarations.html
///
///
///
///
///
///
///
mod use_keyword {}

#[doc(keyword = "where")]
//
/// 添加使用项必须坚持的约束。
///
/// `where` 允许指定生命周期和泛型参数的约束。
/// 引入 `where` 的 [RFC] 包含有关关键字的详细信息。
///
/// # Examples
///
/// `where` 可以用于 traits 的约束:
///
/// ```rust
/// fn new<T: Default>() -> T {
///     T::default()
/// }
///
/// fn new_where<T>() -> T
/// where
///     T: Default,
/// {
///     T::default()
/// }
///
/// assert_eq!(0.0, new());
/// assert_eq!(0.0, new_where());
///
/// assert_eq!(0, new());
/// assert_eq!(0, new_where());
/// ```
///
/// `where` 也可以用于生命周期。
///
/// 这是因为 `longer` 超过 `shorter` 而进行编译，因此要遵守约束:
///
/// ```rust
/// fn select<'short, 'long>(s1: &'short str, s2: &'long str, second: bool) -> &'short str
/// where
///     'long: 'short,
/// {
///     if second { s2 } else { s1 }
/// }
///
/// let outer = String::from("Long living ref");
/// let longer = &outer;
/// {
///     let inner = String::from("Short living ref");
///     let shorter = &inner;
///
///     assert_eq!(select(shorter, longer, false), shorter);
///     assert_eq!(select(shorter, longer, true), longer);
/// }
/// ```
///
/// 另一方面，由于缺少 `where 'b: 'a` 子句，因此无法编译: 未知 `'b` 生命周期的生存时间至少与 `'a` 一样长，这意味着该函数无法确保其始终返回有效的引用:
///
///
/// ```rust,compile_fail,E0623
/// fn select<'a, 'b>(s1: &'a str, s2: &'b str, second: bool) -> &'a str
/// {
///     if second { s2 } else { s1 }
/// }
/// ```
///
/// `where` 也可以用于表示无法使用 `<T: Trait>` 语法编写的更复杂的约束:
///
/// ```rust
/// fn first_or_default<I>(mut i: I) -> I::Item
/// where
///     I: Iterator,
///     I::Item: Default,
/// {
///     i.next().unwrap_or_else(I::Item::default)
/// }
///
/// assert_eq!(first_or_default(vec![1, 2, 3].into_iter()), 1);
/// assert_eq!(first_or_default(Vec::<i32>::new().into_iter()), 0);
/// ```
///
/// `where` 在泛型和生命周期参数可用的任何地方都可用，如标准库中的 [`Cow`](crate::borrow::Cow) 类型所示:
///
/// ```rust
/// # #![allow(dead_code)]
/// pub enum Cow<'a, B>
/// where
///     B: 'a + ToOwned + ?Sized,
///  {
///     Borrowed(&'a B),
///     Owned(<B as ToOwned>::Owned),
/// }
/// ```
///
/// [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md
///
///
///
///
///
///
mod where_keyword {}

// 2018 版关键字

#[doc(alias = "promise")]
#[doc(keyword = "async")]
//
/// 返回 [`Future`]，而不是阻塞当前线程。
///
/// 使用 `fn`，`closure` 或 `block` 前面的 `async` 将标记的代码转换为 `Future`。
/// 因此，该代码将不会立即运行，而只会在返回的 future 为.await 时进行评估。
///
///
/// 我们已经编写了 [async book]，其中详细介绍了 async/await 和与使用线程相比的取舍。
///
/// ## Editions
///
/// `async` 是从 2018 年版开始的关键字。
///
/// 从 1.39 版本开始，它可以在稳定的 rust 中使用。
///
/// [`Future`]: future::Future
/// [async book]: https://rust-lang.github.io/async-book/
mod async_keyword {}

#[doc(keyword = "await")]
//
/// 暂停执行，直到 [`Future`] 的结果准备就绪为止。
///
/// .await`future 将暂停当前函数的执行，直到 `executor` 运行 future 为止。
///
///
/// 阅读 [async book]，以获得有关 async/await 和执行程序如何工作的详细信息。
///
/// ## Editions
///
/// `await` 是从 2018 年版开始的关键字。
///
/// 从 1.39 版本开始，它可以在稳定的 rust 中使用。
///
/// [`Future`]: future::Future
/// [async book]: https://rust-lang.github.io/async-book/
mod await_keyword {}

#[doc(keyword = "dyn")]
//
/// `dyn` 是 [trait 对象] 类型的前缀。
///
/// `dyn` 关键字用于突出显示在关联的 `Trait` 上对方法的调用是动态调度的。
/// 要以这种方式使用 trait，它必须是对象安全的。
///
/// 与泛型参数或 `impl Trait` 不同，编译器不知道要传递的具体类型。即，类型为 [erased]。
/// 因此，`dyn Trait` 引用包含 _two_ 指针。
/// 一个指针指向该数据 (例如，结构体的实例)。
/// 另一个指针指向方法名称为函数指针的 map (称为虚拟方法表或 vtable)。
///
/// 在运行时，当需要在 `dyn Trait` 上调用方法时，将查询 vtable 以获取函数指针，然后调用该函数指针。
///
///
/// 有关 [trait objects][ref-trait-obj] 和 [object safety][ref-obj-safety] 的更多信息，请参见引用。
///
/// ## Trade-offs
///
/// 上面的间接调用是在 `dyn Trait` 上调用函数的额外运行时成本。
/// 动态分配调用的方法通常不能由编译器内联。
///
/// 但是，`dyn Trait` 可能会产生比 `impl Trait` / 泛型参数小的代码，因为该方法不会针对每种具体类型重复。
///
/// [trait object]: ../book/ch17-02-trait-objects.html
/// [ref-trait-obj]: ../reference/types/trait-object.html
/// [ref-obj-safety]: ../reference/items/traits.html#object-safety
/// [erased]: https://en.wikipedia.org/wiki/Type_erasure
///
///
///
///
mod dyn_keyword {}

#[doc(keyword = "union")]
//
/// [Rust 等价于 c 风格的 union][union]。
///
/// `union` 在声明方面看起来像 [`struct`]，但是它的所有字段都存在于同一内存中，彼此叠加在一起。
///
/// 例如，如果我们希望内存中的某些位有时被解释为 `u32`，有时又被解释为 `f32`，则可以这样写:
///
/// ```rust
/// union IntOrFloat {
///     i: u32,
///     f: f32,
/// }
///
/// let mut u = IntOrFloat { f: 1.0 };
/// // 读取一个 union 的字段总是不安全的
/// assert_eq!(unsafe { u.i }, 1065353216);
/// // 通过任何字段进行更新都会修改所有字段
/// u.i = 1073741824;
/// assert_eq!(unsafe { u.f }, 2.0);
/// ```
///
/// # union 上的匹配
///
/// 可以在 `union` 上使用模式匹配。
/// 必须使用单个字段名称，并且该名称必须与 `union` 字段之一的名称匹配。
/// 就像从 `union` 读取一样，在 `union` 上进行模式匹配时也需要 `unsafe`。
///
/// ```rust
/// union IntOrFloat {
///     i: u32,
///     f: f32,
/// }
///
/// let u = IntOrFloat { f: 1.0 };
///
/// unsafe {
///     match u {
///         IntOrFloat { i: 10 } => println!("Found exactly ten!"),
///         // 匹配字段 `f` 将提供 `f32`。
///         IntOrFloat { f } => println!("Found f = {} !", f),
///     }
/// }
/// ```
///
/// # union 字段的引用
///
/// `union` 中的所有字段都在内存中的同一位置，这意味着对于同一生命周期，整个 `union` 都用一个借用。
///
/// ```rust,compile_fail,E0502
/// union IntOrFloat {
///     i: u32,
///     f: f32,
/// }
///
/// let mut u = IntOrFloat { f: 1.0 };
///
/// let f = unsafe { &u.f };
/// // 这将不会编译，因为该字段已被借用，即使只是一成不变
/////
/// let i = unsafe { &mut u.i };
///
/// *i = 10;
/// println!("f = {} and i = {}", f, i);
/// ```
///
/// 有关 `union` 的更多信息，请参见 [union]。
///
/// [`struct`]: keyword.struct.html
/// [union]: ../reference/items/unions.html
///
///
mod union_keyword {}