#[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 _` 则建议使用 [同样的][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}");
/// ```
///
/// 有关更多详细信息，请参阅 [有关 "break 表达式"][Reference on "break expression"] 和 [有关 "break 和循环值"][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 书][Rust Book] 或 [Reference]。
///
/// ## 编译时可评估函数
///
/// `const` 关键字的另一个主要用途是在 `const fn` 中。
/// 这将一个函数标记为可以在 `const` 或 `static` 项的主体中以及在数组初始化程序 (通常称为 "常量上下文") 中被调用。
/// `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#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 书][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 书][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 书][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`] 或 [更高等级的 trait bounds][higher-ranked trait bounds] (`for<'a>`) 实现 trait。
///
/// `for` 关键字在许多语法位置中使用：
///
/// * `for` 用于 for-in 循环 (见下文)。
/// * 在 `impl Trait for Type` 中实现 traits 时使用 `for` (有关更多信息，请参见 [`impl`])。
/// * `for` 也与 `for<'a> &'a T: PartialEq<i32>` 一样用于 [高级 trait 限定][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 {i} never stops being 5");
///     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 {
///             match iter.next() {
///                 None => break,
///                 Some(loop_variable) => { code(); },
///             };
///         },
///     };
///     result
/// }
/// ```
///
/// 有关所显示功能的更多详细信息，请参见 [`IntoIterator`] 文档。
///
/// 有关 for 循环的更多信息，请参见 [Rust 书][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 书][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` 作为它的第一个参数，那么也可以使用方法调用语法调用它，这是任何面向对象的程序员都熟悉的特性，比如 `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 书][book1] 或 [Reference]。
///
/// `impl` 关键字的另一个用法是 `impl Trait` 语法，可以将其视为 "实现此 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 书][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.
///
/// (了解有关 [范围模式][range patterns] 的更多信息)
///
/// [`IntoIterator`]: ../book/ch13-04-performance.html
/// [range patterns]: ../reference/patterns.html?highlight=range#range-patterns
/// [`for`]: keyword.for.html
///
/// `in` 的另一个用途是使用关键字 `pub`。
/// 它允许用户将项声明为仅在给定的作用域内可见。
///
/// ## 字面量示例:
///
///    * `pub(in crate::outer_mod) fn outer_mod_visible_fn() {}` - fn 在 `outer_mod` 中可见
///
/// 从 2018 版开始，`pub(in path)` 的路径必须以 `crate`、`self` 或 `super` 开头。
/// 2015 版还可以使用以 `::` 开头的路径或 crate root 中的模块。
///
/// 有关详细信息，请参见 [Reference]。
///
/// [Reference]: ../reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself
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 书][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 书][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 {data:?} by value");
///
/// // 数据不再可用，它由闭包拥有
/// ```
///
/// 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();
/// ```
///
/// 当涉及 [线程][threads] 时，通常使用 `move`。
///
/// ```rust
/// let data = vec![1, 2, 3];
///
/// std::thread::spawn(move || {
///     println!("captured {data:?} by value")
/// }).join().unwrap();
///
/// // 数据被移动到衍生线程，所以我们不能在这里使用它
/// ```
///
/// `move` 在异步块之前也是有效的。
///
/// ```rust
/// let capture = "hello".to_owned();
/// let block = async move {
///     println!("rust says {capture} from async block");
/// };
/// ```
///
/// 有关 `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);
/// ```
///
/// 可变裸指针的工作方式与可变引用非常相似，但增加了不指向有效对象的可能性。
/// 语法是 `*mut Type`。
///
/// 有关可变引用和指针的更多信息，请参见 [Reference]。
///
/// [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()));
/// ```
///
/// # `&` 与 `ref`
///
/// - `&` 表示您的模式期望引用一个对象。
/// 因此，`&` 是所述模式的一部分: `&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` 会立即从函数返回 (是一个提前返回)：
///
/// ```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`] 关键字关联声明的项和没有关联声明的项。
///
/// 静态项不能移动：
///
/// ```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;
/// }
/// ```
///
/// 可变的 `static`s 就像简单的 `static`s 一样，对它们也有一些限制。有关更多信息，请参见 [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)`。
///
/// 空结构体仅用其名称实例化，不需要其他任何东西。`让事情 =
/// EmptyStruct;`
///
/// # 样式约定
///
/// 结构体总是以 UpperCamelCase 书写，很少有例外。
/// 虽然可以省略结构体的字段列表中的结尾逗号，但为了方便在行中添加和删除字段，通常将其保留下来。
///
/// 有关结构体的更多信息，请查看 [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`] 就是标准库中存在的两个这样的标记 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: 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 对象实现了所有指定的 traits，以及它的 supertraits (如果有的话)。
///
/// 语法如下: `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 impl`，还有 `unsafe fn` - 见下文)。
///
/// 它们不是互斥的，正如在 `unsafe fn` 中可以看到的那样: 默认情况下，`unsafe fn` 的主体被视为不安全块。可以启用 `unsafe_op_in_unsafe_fn` lint 来改变它。
///
/// # 不安全的能力
///
/// **安全 Rust 无论如何都不会导致未定义行为**。这被称为 [可靠性][soundness]: 一个良好类型的程序实际上具有期望的属性。在 [Nomicon][nomicon-soundness] 中，对此主题有更详细的说明。
///
/// 为了确保可靠性，安全 Rust 受到足够的限制，可以自动检查。然而，有时，出于一些聪明得让编译器无法理解的原因，有必要编写正确的代码。在这种情况下，您需要使用不安全的 Rust。
///
/// 除安全 Rust 之外，不安全生锈还具有以下功能：
///
/// - 解引用 [裸指针][raw pointers]
/// - 实现 `unsafe` [`trait`]
/// - 调用 `unsafe` 函数
/// - 可变的 [`static`] (包括 [`extern`]al 的)
/// - [`union`]s 的访问字段
///
/// 但是，这种额外的权力还伴随着额外的责任：现在由你来确保健全性。`unsafe` 关键字有助于清楚地标记需要担心这一点的代码段。
///
/// ## `unsafe` 的不同含义
///
/// 并非所有的 `unsafe` 用法都是等价的：有些用法是为了标记程序员必须检查契约的存在，有些用法是为了表示 "我已经检查了契约，继续并执行此操作吧"。以下 [关于 Rust 内部的讨论][discussion on Rust Internals] 对此有更深入的说明，但这里是要点的总结：
///
/// - `unsafe fn`: 调用这个函数意味着遵守编译器无法强制执行的契约。
/// - `unsafe trait`: 实现 [`trait`] 意味着遵守编译器无法强制执行的契约。
/// - `unsafe {}`: 调用块内操作所必需的契约已经由程序员检查过，并保证得到遵守。
/// - `unsafe impl`: 实现 trait 所必需的契约已经过程序员的检查，并保证得到遵守。
///
/// 默认情况下，`unsafe fn` 也像函数中的代码周围的 `unsafe {}` 块一样。这意味着它不仅仅是给调用者的一个信号，而且还保证函数内部操作的先决条件得到支持。
/// 混合这两种含义可能会令人困惑，因此可以启用 `unsafe_op_in_unsafe_fn` lint 来警告这一点，并且即使在 `unsafe fn` 内部也需要明确的不安全块。
///
/// 有关详细信息，请参见 [Rustonomicon] 和 [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)]
/// #![deny(unsafe_op_in_unsafe_fn)]
///
/// /// 解引用给定的指针。
//////
/// /// # Safety
//////
/// /// `ptr` 必须对齐，并且不能是悬垂的。
/// unsafe fn deref_unchecked(ptr: *const i32) -> i32 {
///     // SAFETY: 调用者需要确保 `ptr` 对齐且可解引用。
///     unsafe { *ptr }
/// }
///
/// let a = 3;
/// let b = &a as *const _;
/// // SAFETY: `a` 尚未丢弃，并且引用始终对齐，因此 `b` 是有效地址。
/////
/// unsafe { assert_eq!(*b, deref_unchecked(b)); };
/// ```
///
/// ## `unsafe` 和 traits
///
/// `unsafe` 和 traits 的相互作用可能令人惊讶，所以让我们用两个例子来对比 `unsafe trait` 中的安全 `fn` 和安全 trait 中的 `unsafe fn` 的两种组合:
///
/// ```rust
/// /// # Safety
//////
/// /// `make_even` 必须返回一个偶数。
/// unsafe trait MakeEven {
///     fn make_even(&self) -> i32;
/// }
///
/// // SAFETY: 我们的 `make_even` 总是返回一些东西。
/// unsafe impl MakeEven for i32 {
///     fn make_even(&self) -> i32 {
///         self << 1
///     }
/// }
///
/// fn use_make_even(x: impl MakeEven) {
///     if x.make_even() % 2 == 1 {
///         // SAFETY: 这永远不会发生，因为所有 `MakeEven` 实现都确保 `make_even` 返回一些东西。
/////
///         unsafe { std::hint::unreachable_unchecked() };
///     }
/// }
/// ```
///
/// 注意 trait 的安全保证是如何被实现维护的，它本身是用来维护 `use_make_even` 调用的不安全函数 `unreachable_unchecked` 的安全保证。
/// `make_even` 本身是一个安全的函数，因为它的*callers* 不必担心任何契约，只需要 `MakeEven` 的*implementation* 来维护某个契约。
/// `use_make_even` 是安全的，因为它可以使用 `MakeEven` 实现的 promise 来维护它调用的 `unsafe fn unreachable_unchecked` 的安全保证。
///
/// 也可以在常规安全 `trait` 中包含 `unsafe fn`:
///
/// ```rust
/// # #![feature(never_type)]
/// #![deny(unsafe_op_in_unsafe_fn)]
///
/// trait Indexable {
///     const LEN: usize;
///
///     /// # Safety
//////
///     /// 调用者必须确保 `idx < LEN`。
///     unsafe fn idx_unchecked(&self, idx: usize) -> i32;
/// }
///
/// // `i32` 的实现不需要做任何契约推理。
/// impl Indexable for i32 {
///     const LEN: usize = 1;
///
///     unsafe fn idx_unchecked(&self, idx: usize) -> i32 {
///         debug_assert_eq!(idx, 0);
///         *self
///     }
/// }
///
/// // 数组的实现利用函数契约在切片上使用 `get_unchecked` 并避免运行时检查。
/////
/// impl Indexable for [i32; 42] {
///     const LEN: usize = 42;
///
///     unsafe fn idx_unchecked(&self, idx: usize) -> i32 {
///         // SAFETY: 根据此 trait 的文档，调用者确保 `idx < 42`.
/////
///         unsafe { *self.get_unchecked(idx) }
///     }
/// }
///
/// // never type 的实现声明长度为 0，这意味着永远不能调用 `idx_unchecked`。
/////
/// impl Indexable for ! {
///     const LEN: usize = 0;
///
///     unsafe fn idx_unchecked(&self, idx: usize) -> i32 {
///         // SAFETY: 根据这个 trait 的文档，调用者确保 `idx < 0`，这是不可能的，所以这是死代码。
/////
///         unsafe { std::hint::unreachable_unchecked() }
///     }
/// }
///
/// fn use_indexable<I: Indexable>(x: I, idx: usize) -> i32 {
///     if idx < I::LEN {
///         // SAFETY: 我们已经检查了 `idx < I::LEN`。
///         unsafe { x.idx_unchecked(idx) }
///     } else {
///         panic!("index out-of-bounds")
///     }
/// }
/// ```
///
/// 这一次，`use_indexable` 是安全的，因为它使用运行时检查来解除 `idx_unchecked` 的安全保证。
/// 实现 `Indexable` 是安全的，因为在编写 `idx_unchecked` 时，我们不必担心: 我们的*callers* 需要履行证明义务 (就像 `use_indexable` 一样)，但 `get_unchecked` 的*实现 * 没有证明义务可抗衡。
/// 当然，`Indexable` 的实现可以选择调用其他不安全的操作，然后它需要一个 `unsafe` *block* 来表明它已经解除了被调用者的证明义务。
/// (我们启用了 `unsafe_op_in_unsafe_fn`，因此 `idx_unchecked` 的主体并不是隐含的不安全块。) 为此，它可以使用所有调用者必须支持的契约 --`idx < LEN`.
///
/// 正式地说，trait 中的 `unsafe fn` 是一个具有*preconditions* 的函数，它超出了参数类型 (例如 `idx < LEN`) 编码的那些，而 `unsafe trait` 可以声明它的某些函数具有*postconditions* 超出那些编码在返回类型 (例如返回偶数)。
///
/// 如果 trait 需要一个具有额外前置条件和额外后置条件的函数，那么它需要一个 `unsafe trait` 中的 `unsafe fn`。
///
/// [`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
/// [Rustonomicon]: ../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
/// [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` 允许指定生命周期和泛型参数的约束。
/// [RFC] 介绍 `where` 包含有关关键字的详细信息。
///
/// # 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
/// 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([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: 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`]ed 时进行计算。
///
///
/// 我们已经编写了 [async book]，并详细介绍了 `async`/`await` 以及与使用线程相比的权衡。
///
/// ## Editions
///
/// `async` 是 2018 版以后推出的关键字。
///
/// 从 1.39 版本开始，它可用于稳定的 Rust。
///
/// [`Future`]: future::Future
/// [`.await`]: ../std/keyword.await.html
/// [async book]: https://rust-lang.github.io/async-book/
mod async_keyword {}

#[doc(keyword = "await")]
//
/// 暂停执行，直到 [`Future`] 的结果准备就绪为止。
///
/// `.await` 执行 future 将暂停当前函数的执行，直到执行程序运行 future 完成。
///
///
/// 阅读 [async book] 以了解有关 [`async`]/`await` 和执行器如何工作的详细信息。
///
/// ## Editions
///
/// `await` 是 2018 版以后推出的关键词。
///
/// 从 1.39 版本开始，它可用于稳定的 Rust。
///
/// [`Future`]: future::Future
/// [async book]: https://rust-lang.github.io/async-book/
/// [`async`]: ../std/keyword.async.html
mod await_keyword {}

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