#[doc(primitive = "bool")]
#[doc(alias = "true")]
#[doc(alias = "false")]
/// 布尔类型。
///
/// `bool` 代表一个值，只能是 `true` 或 `false`。
/// 如果将 `bool` 转换为整数，则 `true` 将为 1，`false` 将为 0。
///
/// # 基本用法
///
/// `bool` 实现各种 traits，例如 [`BitAnd`]，[`BitOr`]，[`Not`] 等，它们使我们能够使用 `&`，`|` 和 `!` 执行布尔运算。
///
///
/// `if` 需要 `bool` 值作为它的条件。
/// [`assert!`], 在测试中是重要的宏，它检查表达式是否为 `true` 和 panics (如果不是)。
///
/// ```
/// let bool_val = true & false | false;
/// assert!(!bool_val);
/// ```
///
/// [`BitAnd`]: ops::BitAnd
/// [`BitOr`]: ops::BitOr
/// [`Not`]: ops::Not
///
/// # Examples
///
/// `bool` 用法的一个简单示例:
///
/// ```
/// let praise_the_borrow_checker = true;
///
/// // 使用 `if` 有条件
/// if praise_the_borrow_checker {
///     println!("oh, yeah!");
/// } else {
///     println!("what?!!");
/// }
///
/// // ... 或者，匹配模式
/// match praise_the_borrow_checker {
///     true => println!("keep praising!"),
///     false => println!("you should praise!"),
/// }
/// ```
///
/// 另外，由于 `bool` 实现了 [`Copy`] trait，因此我们不必担心移动语义 (就像整数和浮点图元一样)。
///
/// 现在将 `bool` 强制转换为整数类型的示例:
///
/// ```
/// assert_eq!(true as i32, 1);
/// assert_eq!(false as i32, 0);
/// ```
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_bool {}

#[doc(primitive = "never")]
#[doc(alias = "!")]
//
/// `!` 类型，也称为 "never"。
///
/// `!` 表示永远无法解析为任何值的计算类型。
/// 例如，[`exit`] 函数 `fn exit(code: i32) -> !` 退出该进程而不返回，因此返回 `!`。
///
/// `break`, `continue` 和 `return` 表达式也具有 `!` 类型。例如，我们可以写:
///
/// ```
/// #![feature(never_type)]
/// # fn foo() -> u32 {
/// let x: ! = {
///     return 123
/// };
/// # }
/// ```
///
/// 尽管 `let` 在这里毫无意义，但它说明了 `!` 的含义。由于从未给 `x` 赋值 (因为 `return` 从整个函数返回)，因此可以给 `x` 指定 `!` 类型。我们也可以将 `return 123` 替换为 `panic!` 或永无休止的 `loop`，并且此代码仍然有效。
///
/// 以下代码更实际地使用 `!`:
///
/// ```
/// # fn get_a_number() -> Option<u32> { None }
/// # loop {
/// let num: u32 = match get_a_number() {
///     Some(num) => num,
///     None => break,
/// };
/// # }
/// ```
///
/// 两个匹配分支都必须产生 [`u32`] 类型的值，但是由于 `break` 根本不会产生值，我们知道它永远不会产生不是 [`u32`] 的值。这说明了 `!` 类型的另一种行为 - 类型为 `!` 的表达式将强制转换为任何其他类型。
///
/// [`u32`]: prim@u32
/// [`exit`]: process::exit
///
/// # `!` 和泛型
///
/// ## 绝对的错误
///
/// 您将看到显式使用的 `!` 的主要位置是泛型代码。考虑 [`FromStr`] trait:
///
/// ```
/// trait FromStr: Sized {
///     type Err;
///     fn from_str(s: &str) -> Result<Self, Self::Err>;
/// }
/// ```
///
/// 当为 [`String`] 实现此 trait 时，我们需要为 [`Err`] 选择一个类型。并且由于将字符串转换为字符串永远不会导致错误，因此适当的类型是 `!`。
/// (当前实际使用的类型是一个没有成员的枚举，尽管这只是因为 `!` 以后才会被添加到 Rust 中，并且将来可能会发生变化。) 对于 [`Err`] 类型的 `!`，如果我们由于某种原因不得不调用 [`String::from_str`]，那么结果将是 [`Result<String, !>`]，我们可以像这样解包:
///
///
/// ```
/// #![feature(exhaustive_patterns)]
/// use std::str::FromStr;
/// let Ok(s) = String::from_str("hello");
/// ```
///
/// 由于 [`Err`] 成员包含 `!`，因此永远不会发生。如果存在 `exhaustive_patterns` 功能，则意味着我们只需采用 [`Ok`] 成员就可以在 [`Result<T, !>`] 上进行全面匹配。
/// 这说明了 `!` 的另一种行为 - 它可以用于 "delete" 泛型 (如 `Result`) 中的某些枚举成员。
///
/// ## 无限循环
///
/// 尽管 [`Result<T, !>`] 对于消除错误非常有用，但 `!` 也可以用于消除成功。如果我们将 [`Result<T, !>`] 视为 "if this function returns, it has not errored,"，那么我们也会非常直观地想到 [`Result<!, E>`]: 如果函数返回，则 *有* 错误。
///
/// 例如，考虑一个简单的 Web 服务器的情况，它可以简化为:
///
/// ```ignore (hypothetical-example)
/// loop {
///     let (client, request) = get_request().expect("disconnected");
///     let response = request.process();
///     response.send(client);
/// }
/// ```
///
/// 目前，这并不理想，因为只要无法建立新的连接，我们就简单地使用 panic。
/// 相反，我们想跟踪此错误，如下所示:
///
/// ```ignore (hypothetical-example)
/// loop {
///     match get_request() {
///         Err(err) => break err,
///         Ok((client, request)) => {
///             let response = request.process();
///             response.send(client);
///         },
///     }
/// }
/// ```
///
/// 现在，当服务器断开连接时，我们以错误退出循环而不是恐慌。虽然简单地返回错误可能很直观，但我们可能希望将其包装在 [`Result<!, E>`] 中:
///
/// ```ignore (hypothetical-example)
/// fn server_loop() -> Result<!, ConnectionError> {
///     loop {
///         let (client, request) = get_request()?;
///         let response = request.process();
///         response.send(client);
///     }
/// }
/// ```
///
/// 现在，我们可以使用 `?` 代替 `match`，并且返回类型更有意义: 如果循环停止，则意味着发生了错误。我们甚至不必将循环包装在 `Ok` 中，因为 `!` 会自动强制转换为 `Result<!, ConnectionError>`。
///
/// [`String::from_str`]: str::FromStr::from_str
/// [`String`]: string::String
/// [`FromStr`]: str::FromStr
///
/// # `!` 和 traits
///
/// 编写自己的 traits 时，只要有明显的 `impl` 而不是 `panic!`，`!` 就应该有一个 `impl`。原因是返回 `impl Trait` 且 `!` 没有 `impl` 的函数不能作为它的唯一可能的代码路径发散。
/// 换句话说，它们不能从每个代码路径返回 `!`。
/// 例如，此代码不会编译:
///
/// ```compile_fail
/// use std::ops::Add;
///
/// fn foo() -> impl Add<u32> {
///     unimplemented!()
/// }
/// ```
///
/// 但是这段代码可以做到:
///
/// ```
/// use std::ops::Add;
///
/// fn foo() -> impl Add<u32> {
///     if true {
///         unimplemented!()
///     } else {
///         0
///     }
/// }
/// ```
///
/// 原因是，在第一个示例中，`!` 可以强制转换为许多可能的类型，因为许多类型实现了 `Add<u32>`。
/// 但是，在第二个示例中，`else` 分支返回 `0`，编译器从返回类型推断出它为 `u32` 类型。由于 `u32` 是具体类型，因此 `!` 可以并且将被强制使用。有关此 `!` 的更多信息，请参见问题 [#36375]。
///
/// [#36375]: https://github.com/rust-lang/rust/issues/36375
///
/// 但是，事实证明，大多数 traits 都可以将 `impl` 用作 `!`。以 [`Debug`] 为例:
///
/// ```
/// #![feature(never_type)]
/// # use std::fmt;
/// # trait Debug {
/// #     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result;
/// # }
/// impl Debug for ! {
///     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
///         *self
///     }
/// }
/// ```
///
/// 我们再次使用 `! ` 的功能来强制转换为任何其他类型，在本例中为 [`fmt::Result`]。由于此方法将 `&!` 作为参数，因此我们知道它永远不能被调用 (因为没有 `!` 类型的值可以调用它)。
/// 编写 `*self` 实质上就是告诉编译器 "We know that this code can never be run, so just treat the entire function body as having type [`fmt::Result`]"。
/// 当为 `!` 实现 traits 时，可以使用这种模式。
/// 通常，任何仅具有采用 `self` 参数的方法的 trait 都应具有这样的含义。
///
/// 另一方面，不适合实现的一个 trait 是 [`Default`]:
///
/// ```
/// trait Default {
///     fn default() -> Self;
/// }
/// ```
///
/// 由于 `!` 没有值，因此也没有默认值。的确，我们可以为此编写一个 `impl`，它只是 panics，但是对于任何类型都一样 (我们可以通过仅将 [`default()`] panic 制作为 (eg.) [`File`] 来使用 `impl Default`)。
///
/// [`File`]: fs::File
/// [`Debug`]: fmt::Debug
/// [`default()`]: Default::default
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[unstable(feature = "never_type", issue = "35121")]
mod prim_never {}

#[doc(primitive = "char")]
//
/// 一个字符类型。
///
/// `char` 类型代表一个字符。
/// 更具体地说，由于 'character' 不是 Unicode 中定义明确的概念，因此 `char` 是 `[Unicode 标量值]`，与 `[Unicode 代码点]` 相似但不相同。
///
///
/// [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value
/// [Unicode code point]: https://www.unicode.org/glossary/#code_point
///
/// 本文档描述了 `char` 类型上的许多方法和 trait 实现。
/// 由于技术原因，[the `std::char` module](char/index.html) 中还有其他单独的文档。
///
/// # Representation
///
/// `char` 大小始终为四个字节。这与给定字符作为 [`String`] 的一部分的表示形式不同。例如:
///
/// ```
/// let v = vec!['h', 'e', 'l', 'l', 'o'];
///
/// // 五个元素乘以每个元素四个字节
/// assert_eq!(20, v.len() * std::mem::size_of::<char>());
///
/// let s = String::from("hello");
///
/// // 5 个元素乘以每个元素一个字节
/// assert_eq!(5, s.len() * std::mem::size_of::<u8>());
/// ```
///
/// [`String`]: string/struct.String.html
///
/// 与往常一样，请记住，对于 'character' 的直观理解可能不会 map 到 Unicode 的定义。
/// 例如，尽管看起来相似，但 'é' 字符是一个 Unicode 代码点，而 'é' 是两个 Unicode 代码点:
///
/// ```
/// let mut chars = "é".chars();
/// // U+00e9: 带有小写字母的拉丁小写字母 e
/// assert_eq!(Some('\u{00e9}'), chars.next());
/// assert_eq!(None, chars.next());
///
/// let mut chars = "é".chars();
/// // U+0065: 拉丁小写字母 e
/// assert_eq!(Some('\u{0065}'), chars.next());
/// // U+0301: 结合重音
/// assert_eq!(Some('\u{0301}'), chars.next());
/// assert_eq!(None, chars.next());
/// ```
///
/// 这意味着 _will_ 上方的第一个字符串的内容适合 `char`，而第二个字符串 _will_ 的内容则不会。
/// 尝试使用第二个字符串的内容创建 `char` 字面量会产生错误:
///
/// ```text
/// error: character literal may only contain one codepoint: 'é'
/// let c = 'é';
///         ^^^
/// ```
///
/// `char` 的 4 字节固定大小的另一个含义是，每个字符处理可能最终会使用更多的内存:
///
/// ```
/// let s = String::from("love: ❤️");
/// let v: Vec<char> = s.chars().collect();
///
/// assert_eq!(12, std::mem::size_of_val(&s[..]));
/// assert_eq!(32, std::mem::size_of_val(&v[..]));
/// ```
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_char {}

#[doc(primitive = "unit")]
#[doc(alias = "(")]
#[doc(alias = ")")]
#[doc(alias = "()")]
//
/// `()` 类型，也称为 "unit"。
///
/// `()` 类型只有一个值 `()`，在没有其他有意义的值可以返回时使用。
/// `()` 最常见的隐含形式: 没有 `-> ...` 的函数隐含具有返回类型 `()`，即，它们是等效的:
///
/// ```rust
/// fn long() -> () {}
///
/// fn short() {}
/// ```
///
/// 分号 `;` 可用于在块末尾丢弃表达式的结果，从而使表达式 (从而使该块) 的值为 `()`。
///
/// 例如，
///
/// ```rust
/// fn returns_i64() -> i64 {
///     1i64
/// }
/// fn returns_unit() {
///     1i64;
/// }
///
/// let is_i64 = {
///     returns_i64()
/// };
/// let is_unit = {
///     returns_i64();
/// };
/// ```
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_unit {}

#[doc(alias = "ptr")]
#[doc(primitive = "pointer")]
//
/// 原始，不安全的指针 `*const T` 和 `* mut T`。
///
/// *[See also the `std::ptr` module](ptr).*
///
/// 在 Rust 中使用裸指针并不常见，通常仅限于几种模式。
/// 裸指针可以是未对齐的或 [`null`]。但是，当解引用裸指针 (使用 `*` 运算符) 时，它必须为非 null 并对齐。
///
/// 使用 `*ptr = data` 通过裸指针存储会在旧值上调用 `drop`，因此，如果该类型具有 drop glue 并且尚未初始化内存，则必须使用 [`write`]; 否则，将在未初始化的内存上调用 `drop`。
///
///
/// 使用 [`null`] 和 [`null_mut`] 函数创建空指针，并使用 `*const T` 和 `* mut T` 类型的 [`is_null`] 方法检查空值。
/// `*const T` 和 `* mut T` 类型还定义了用于指针数学的 [`offset`] 方法。
///
/// # 创建裸指针的常用方法
///
/// ## 1. 强制引用 (`&T`) 或可变引用 (`&mut T`)。
///
/// ```
/// let my_num: i32 = 10;
/// let my_num_ptr: *const i32 = &my_num;
/// let mut my_speed: i32 = 88;
/// let my_speed_ptr: *mut i32 = &mut my_speed;
/// ```
///
/// 要获得指向 boxed 值的指针，请解引用 box:
///
/// ```
/// let my_num: Box<i32> = Box::new(10);
/// let my_num_ptr: *const i32 = &*my_num;
/// let mut my_speed: Box<i32> = Box::new(88);
/// let my_speed_ptr: *mut i32 = &mut *my_speed;
/// ```
///
/// 这不会获得原始分配的所有权，并且以后不需要任何资源管理，但是您一定不能在其生命周期之后使用该指针。
///
/// ## 2. 消费 box (`Box<T>`)。
///
/// [`into_raw`] 函数使用 box 并返回裸指针。它不会销毁 `T` 或释放任何内存。
///
/// ```
/// let my_speed: Box<i32> = Box::new(88);
/// let my_speed: *mut i32 = Box::into_raw(my_speed);
///
/// // 通过拥有原始 `Box<T>` 的所有权，我们有义务稍后将其放在一起销毁。
/////
/// unsafe {
///     drop(Box::from_raw(my_speed));
/// }
/// ```
///
/// 请注意，此处对 [`drop`] 的调用是为了清楚起见 - 表示我们已经完成了给定值的操作，应将其销毁。
///
/// ## 3. 使用 `ptr::addr_of!` 创建它
///
/// 您可以使用宏 [`ptr::addr_of!`] (对于 `*const T`) 和 [`ptr::addr_of_mut!`] (对于 `*mut T`)，而不是强制引用裸指针。
/// 这些宏允许您创建裸指针指向您无法创建引用的字段 (不会导致未定义的行为)，例如未对齐的字段。
/// 如果涉及包装的结构或未初始化的内存，这可能是必要的。
///
/// ```
/// #[derive(Debug, Default, Copy, Clone)]
/// #[repr(C, packed)]
/// struct S {
///     aligned: u8,
///     unaligned: u32,
/// }
/// let s = S::default();
/// let p = std::ptr::addr_of!(s.unaligned); // 不允许强制
/// ```
///
/// ## 4. 从 C 获取它。
///
/// ```
/// # #![feature(rustc_private)]
/// extern crate libc;
///
/// use std::mem;
///
/// unsafe {
///     let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>()) as *mut i32;
///     if my_num.is_null() {
///         panic!("failed to allocate memory");
///     }
///     libc::free(my_num as *mut libc::c_void);
/// }
/// ```
///
/// 通常，您实际上不会使用 Rust 中的 `malloc` 和 `free`，但是 C API 通常会发出很多指针，因此 Rust 中的裸指针常见来源。
///
/// [`null`]: ptr::null
/// [`null_mut`]: ptr::null_mut
/// [`is_null`]: pointer::is_null
/// [`offset`]: pointer::offset
/// [`into_raw`]: Box::into_raw
/// [`drop`]: mem::drop
/// [`write`]: ptr::write
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_pointer {}

#[doc(alias = "[]")]
#[doc(alias = "[T;N]")] // 不幸的是，rustdoc 没有对别名的模糊搜索
#[doc(alias = "[T; N]")]
#[doc(primitive = "array")]
/// 一个固定大小的数组，表示为 `[T; N]`，用于元素类型 `T` 和非负编译时常量大小， `N`.
///
/// 创建数组有两种语法形式:
///
/// * 每个元素的列表，即 `[x, y, z]`.
/// * 重复表达式 `[x; N]`，该数组生成包含 `x` 的 `N` 副本的数组。
///   `x` 的类型必须为 [`Copy`]。
///
/// 请注意，`[expr; 0]` 是允许的，并产生一个空数组。
/// 然而，这仍然会计算 `expr`，并立即丢弃结果值，因此请注意副作用。
///
/// 如果元素类型允许，则 *any* 大小的数组将实现以下 traits:
///
/// - [`Copy`]
/// - [`Clone`]
/// - [`Debug`]
/// - [`IntoIterator`] (为 `[T; N]`、`&[T; N]` 和 `&mut [T; N]` 实现)
/// - [`PartialEq`], [`PartialOrd`], [`Eq`], [`Ord`]
/// - [`Hash`]
/// - [`AsRef`], [`AsMut`]
/// - [`Borrow`], [`BorrowMut`]
///
/// 如果元素类型允许，则大小为 0 到 32 (inclusive) 的数组将实现 [`Default`] trait。
/// 作为权宜之计，trait 实现是静态生成的，最大大小为 32。
///
/// 数组强制转换为 [slices (`[T]`) ][slice]，因此可以在数组上调用 slice 方法。实际上，这提供了用于处理数组的大多数 API。
/// 切片具有动态大小，并且不强制转换为数组。
///
/// 您可以使用 [slice pattern] 将元素移出数组。如果需要一个元素，请参见 [`mem::replace`]。
///
/// # Examples
///
/// ```
/// let mut array: [i32; 3] = [0; 3];
///
/// array[1] = 1;
/// array[2] = 2;
///
/// assert_eq!([1, 2], &array[1..]);
///
/// // 该循环打印: 0 1 2
/// for x in array {
///     print!("{} ", x);
/// }
/// ```
///
/// 您还可以迭代数组元素的引用:
///
/// ```
/// let array: [i32; 3] = [0; 3];
///
/// for x in &array { }
/// ```
///
/// 您可以使用 [slice pattern] 将元素移出数组:
///
/// ```
/// fn move_away(_: String) { /* Do interesting things. */ }
///
/// let [john, roa] = ["John".to_string(), "Roa".to_string()];
/// move_away(john);
/// move_away(roa);
/// ```
///
/// # Editions
///
/// 在 Rust 1.53 之前，数组没有通过值实现 `IntoIterator`，因此该方法调用 `array.into_iter()` 自动引用到切片迭代器中。
/// 现在，为了兼容性，旧的行为被保留在 2015 和 2018 年版本的 Rust 中，忽略了 `IntoIterator` 的值。
/// 将来，2015 年和 2018 年版本的行为可能会与以后版本的行为一致。
///
/// ```rust,edition2018
/// # #![allow(array_into_iter)] // 覆盖我们的 `deny(warnings)`
/// let array: [i32; 3] = [0; 3];
///
/// // 这将创建一个切片迭代器，产生对每个值的引用。
/// for item in array.into_iter().enumerate() {
///     let (i, x): (usize, &i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
///
/// // `array_into_iter` lint 建议进行此更改以实现未来兼容性:
/// for item in array.iter().enumerate() {
///     let (i, x): (usize, &i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
///
/// // 您可以使用 `IntoIterator::into_iter` 或 `std::array::IntoIter::new` 按值显式迭代数组:
/////
/// for item in IntoIterator::into_iter(array).enumerate() {
///     let (i, x): (usize, i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
/// ```
///
/// 从 2021 年版开始，`array.into_iter()` 通常会使用 `IntoIterator` 按值迭代，`iter()` 应该像以前的版本一样用于按引用迭代。
///
///
/// ```rust,edition2021,ignore
/// # // FIXME: 被忽略，因为 2021 测试仍然不稳定
/// let array: [i32; 3] = [0; 3];
///
/// // 这通过引用进行迭代:
/// for item in array.iter().enumerate() {
///     let (i, x): (usize, &i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
///
/// // 这是按值迭代的:
/// for item in array.into_iter().enumerate() {
///     let (i, x): (usize, i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
/// ```
///
/// 未来的语言版本可能会开始将 2015 和 2018 版的 `array.into_iter()` 语法与 2021 版相同。
/// 因此，在编写使用这些旧版本的代码时仍应牢记这一更改，以防止将来出现破坏。
/// 实现这一点最安全的方法是避免这些版本中的 `into_iter` 语法。
/// 如果版本更新不是不可行/不理想，则有多种选择:
/// * 使用 `iter`，相当于旧行为，创建引用
/// * 使用 [`array::IntoIter`]，相当于 2021 年后的行为 (Rust 1.51+)
/// * 替换 `for ....
/// in array.into_iter() {` 和 `for ...
/// in array {`，相当于 2021 年后的行为 (Rust 1.53+)
///
/// ```rust,edition2018
/// use std::array::IntoIter;
///
/// let array: [i32; 3] = [0; 3];
///
/// // 这通过引用进行迭代:
/// for item in array.iter() {
///     let x: &i32 = item;
///     println!("{}", x);
/// }
///
/// // 这是按值迭代的:
/// for item in IntoIter::new(array) {
///     let x: i32 = item;
///     println!("{}", x);
/// }
///
/// // 这是按值迭代的:
/// for item in array {
///     let x: i32 = item;
///     println!("{}", x);
/// }
///
/// // IntoIter 也可以启动一个链。
/// // 这是按值迭代的:
/// for item in IntoIter::new(array).enumerate() {
///     let (i, x): (usize, i32) = item;
///     println!("array[{}] = {}", i, x);
/// }
/// ```
///
/// [slice]: prim@slice
/// [`Debug`]: fmt::Debug
/// [`Hash`]: hash::Hash
/// [`Borrow`]: borrow::Borrow
/// [`BorrowMut`]: borrow::BorrowMut
/// [slice pattern]: ../reference/patterns.html#slice-patterns
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_array {}

#[doc(primitive = "slice")]
#[doc(alias = "[")]
#[doc(alias = "]")]
#[doc(alias = "[]")]
/// 动态大小的视图到一个连续的序列， `[T]`.
/// 这里的连续意味着元素的布局应使每个元素与其相邻元素之间的距离相同。
///
/// *[See also the `std::slice` module](crate::slice).*
///
/// 切片是一个内存块的视图，表示为一个指针和一个长度。
///
/// ```
/// // 切片 Vec
/// let vec = vec![1, 2, 3];
/// let int_slice = &vec[..];
/// // 将数组强制转换为切片
/// let str_slice: &[&str] = &["one", "two", "three"];
/// ```
///
/// 切片是可变的或共享的。
/// 共享切片类型为 `&[T]`，而可变切片类型为 `&mut [T]`，其中 `T` 表示元素类型。
/// 例如，您可以更改可变切片所指向的内存块:
///
/// ```
/// let mut x = [1, 2, 3];
/// let x = &mut x[..]; // 取 `x` 的完整切片。
/// x[1] = 7;
/// assert_eq!(x, &[1, 7, 3]);
/// ```
///
/// 当切片存储所引用序列的长度时，它们的指针大小是 [`Sized`](marker/trait.Sized.html) 类型的两倍。
///
/// 另请参见 [dynamically sized types](../reference/dynamically-sized-types.html) 上的引用。
///
/// ```
/// # use std::rc::Rc;
/// let pointer_size = std::mem::size_of::<&u8>();
/// assert_eq!(2 * pointer_size, std::mem::size_of::<&[u8]>());
/// assert_eq!(2 * pointer_size, std::mem::size_of::<*const [u8]>());
/// assert_eq!(2 * pointer_size, std::mem::size_of::<Box<[u8]>>());
/// assert_eq!(2 * pointer_size, std::mem::size_of::<Rc<[u8]>>());
/// ```
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_slice {}

#[doc(primitive = "str")]
//
/// 字符串片。
///
/// *[See also the `std::str` module](crate::str).*
///
/// `str` 类型，也称为字符串切片，是最原始的字符串类型。
/// 通常以借用形式出现 `&str`.
/// 也是字面量的类型 `&'static str`.
///
/// 字符串片始终是有效的 UTF-8。
///
/// # Examples
///
/// 字符串字面量是字符串切片:
///
/// ```
/// let hello = "Hello, world!";
///
/// // 带有明确的类型注解
/// let hello: &'static str = "Hello, world!";
/// ```
///
/// 它们是 `'static`，因为它们直接存储在最终二进制文件中，因此在 `'static` 持续时间内有效。
///
///
/// # Representation
///
/// `&str` 由两个部分组成: 一个指向某些字节的指针和一个长度。
/// 您可以使用 [`as_ptr`] 和 [`len`] 方法查看它们:
///
/// ```
/// use std::slice;
/// use std::str;
///
/// let story = "Once upon a time...";
///
/// let ptr = story.as_ptr();
/// let len = story.len();
///
/// // story 有十九个字节
/// assert_eq!(19, len);
///
/// // 我们可以根据 ptr 和 len 重新构建一个 str。
/// // 这都是不安全的，因为我们有责任确保两个组件均有效:
/// let s = unsafe {
///     // 首先，我们建立一个 &[u8] ...
///     let slice = slice::from_raw_parts(ptr, len);
///
///     // ... 然后将该切片转换为字符串
///     str::from_utf8(slice)
/// };
///
/// assert_eq!(s, Ok(story));
/// ```
///
/// [`as_ptr`]: str::as_ptr
/// [`len`]: str::len
///
/// Note: 本示例显示了 `&str` 的内部结构。
/// `unsafe` 通常情况下，不应使用它来获取字符串切片。
/// 请改用 `as_str`。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_str {}

#[doc(primitive = "tuple")]
#[doc(alias = "(")]
#[doc(alias = ")")]
#[doc(alias = "()")]
//
/// 有限的异质序列， `(T, U, ..)`.
///
/// 让我们依次介绍每个:
///
/// 元组是有限的。换句话说，元组具有长度。这是长度为 `3` 的元组:
///
/// ```
/// ("hello", 5, 'c');
/// ```
///
/// 'Length' 在这里有时也称为 'arity'; 每个不同长度的元组都是不同的，不同的类型。
///
/// 元组是异构的。这意味着元组的每个元素可以具有不同的类型。
/// 在上面的元组中，其类型为:
///
/// ```
/// # let _:
/// (&'static str, i32, char)
/// # = ("hello", 5, 'c');
/// ```
///
/// 元组是一个序列。这意味着可以按位置访问它们;
/// 这称为元组索引，它看起来像这样:
///
/// ```rust
/// let tuple = ("hello", 5, 'c');
///
/// assert_eq!(tuple.0, "hello");
/// assert_eq!(tuple.1, 5);
/// assert_eq!(tuple.2, 'c');
/// ```
///
/// 元组的顺序性质适用于各种 traits 的实现。
/// 例如，在 `PartialOrd` 和 `Ord` 中，顺序比较元素，直到找到第一个非等式集合。
///
///
/// 有关元组的更多信息，请参见 [the book](../book/ch03-02-data-types.html#the-tuple-type)。
///
/// # Trait 实现
///
/// 如果元组中的每个类型都实现以下 traits 之一，则元组本身也将实现它。
///
/// * [`Clone`]
/// * [`Copy`]
/// * [`PartialEq`]
/// * [`Eq`]
/// * [`PartialOrd`]
/// * [`Ord`]
/// * [`Debug`]
/// * [`Default`]
/// * [`Hash`]
///
/// [`Debug`]: fmt::Debug
/// [`Hash`]: hash::Hash
///
/// 由于 Rust 的类型系统中的临时限制，这些 traits 仅在 Arity 12 以下的元组上实现。
/// 未来，这可能会改变。
///
/// # Examples
///
/// 基本用法:
///
/// ```
/// let tuple = ("hello", 5, 'c');
///
/// assert_eq!(tuple.0, "hello");
/// ```
///
/// 当您要返回多个值时，通常将元组用作返回类型:
///
/// ```
/// fn calculate_point() -> (i32, i32) {
///     // 不要进行计算，这不是示例的重点
///     (4, 5)
/// }
///
/// let point = calculate_point();
///
/// assert_eq!(point.0, 4);
/// assert_eq!(point.1, 5);
///
/// // 将此与模式结合起来会更好。
///
/// let (x, y) = calculate_point();
///
/// assert_eq!(x, 4);
/// assert_eq!(y, 5);
/// ```
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_tuple {}

#[doc(primitive = "f32")]
/// 32 位浮点类型 (特别是 IEEE 754-2008 中定义的 "binary32" 类型)。
///
/// 此类型可以表示各种十进制数字，例如 `3.5`，`27`，`-113.75`，`0.0078125`，`34359738368`，`0`，`-1`。因此，与整数类型 (例如 `i32`) 不同，浮点类型也可以表示非整数。
///
/// 但是，能够表示这么广泛的数字是以牺牲精度为代价的: 浮点数只能表示某些实数，并且计算时会将浮点数舍入到附近的可表示数字。
/// 例如，`5.0` 和 `1.0` 可以精确地表示为 `f32`，但是 `1.0 / 5.0` 会导致 `0.20000000298023223876953125`，因为 `0.2` 不能精确地表示为 `f32`。
/// 但是请注意，带有 `println` 的浮动彩信和朋友经常会丢弃无关紧要的数字: `println!("{}", 1.0f32 / 5.0f32)` 会打印 `0.2`。
///
/// 此外，`f32` 可以表示一些特殊值:
///
/// - -0.0: IEEE 754 浮点数有一个表示它们的符号的位，所以 `-0.0` 是一个可能的值。对于比较 `-0.0 = +0.0`，但浮点运算可以通过算术运算携带符号位。
/// 这意味着 `-0.0 × +0.0` 产生 `-0.0`，四舍五入到小于浮点值的负数也产生 `-0.0`。
/// - [∞](#associatedconstant.INFINITY) 和 [−∞](#associatedconstant.NEG_INFINITY): 这些是通过 `1.0 / 0.0` 之类的计算得出的。
/// - [NaN (not a number)](#associatedconstant.NAN): 该值是由 `(-1.0).sqrt()` 之类的计算得出的。NaN 有一些潜在的意外行为: 它不等于任何浮点数，包括它本身! 它也不小于或大于任何浮点数，因此无法分类。
///
/// 最后，由于操作数之一为 NaN 的几乎所有计算也将产生 NaN，因此它被认为具有传染性。
///
/// 有关浮点数的更多信息，请参见 [Wikipedia][wikipedia]。
///
/// *[See also the `std::f32::consts` module](crate::f32::consts).*
///
/// [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_f32 {}

#[doc(primitive = "f64")]
/// 64 位浮点类型 (特别是 IEEE 754-2008 中定义的 "binary64" 类型)。
///
/// 此类型与 [`f32`] 非常相似，但是通过使用两倍的位来提高精度。
/// 请参见 [`f32`] 的文档或关于双精度值的 [维基百科][wikipedia] 了解更多信息。
///
///
/// *[See also the `std::f64::consts` module](crate::f64::consts).*
///
/// [`f32`]: prim@f32
/// [wikipedia]: https://en.wikipedia.org/wiki/Double-precision_floating-point_format
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_f64 {}

#[doc(primitive = "i8")]
//
/// 8 位带符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i8 {}

#[doc(primitive = "i16")]
//
/// 16 位带符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i16 {}

#[doc(primitive = "i32")]
//
/// 32 位带符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i32 {}

#[doc(primitive = "i64")]
//
/// 64 位带符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i64 {}

#[doc(primitive = "i128")]
//
/// 128 位带符号整数类型。
#[stable(feature = "i128", since = "1.26.0")]
mod prim_i128 {}

#[doc(primitive = "u8")]
//
/// 8 位无符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u8 {}

#[doc(primitive = "u16")]
//
/// 16 位无符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u16 {}

#[doc(primitive = "u32")]
//
/// 32 位无符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u32 {}

#[doc(primitive = "u64")]
//
/// 64 位无符号整数类型。
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u64 {}

#[doc(primitive = "u128")]
//
/// 128 位无符号整数类型。
#[stable(feature = "i128", since = "1.26.0")]
mod prim_u128 {}

#[doc(primitive = "isize")]
//
/// 指针大小的有符号整数类型。
///
/// 该原语的大小是引用内存中任何位置所需要的字节数。
/// 例如，在 32 位目标上，这是 4 个字节，而在 64 位目标上，这是 8 个字节。
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_isize {}

#[doc(primitive = "usize")]
//
/// 指针大小的无符号整数类型。
///
/// 该原语的大小是引用内存中任何位置所需要的字节数。
/// 例如，在 32 位目标上，这是 4 个字节，而在 64 位目标上，这是 8 个字节。
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_usize {}

#[doc(primitive = "reference")]
#[doc(alias = "&")]
#[doc(alias = "&mut")]
//
/// 引用，共享和可变。
///
/// 引用代表某种拥有值的借用。您可以通过在值上使用 `&` 或 `&mut` 运算符，或者使用 `ref` 或 `ref mut` 模式来获得一个。
///
/// 对于熟悉指针的人来说，引用只是假定为已对齐的指针，而不是 null，并且指向包含有效值 `T` 的内存 - 例如，`&bool` 只能指向包含整数值 `1` (`true`) 或 `0` (`false`)，但是创建指向包含值 `3` 的分配的 `&bool` 会导致未定义的行为。
///
/// 实际上，`Option<&T>` 与可为空但对齐的指针具有相同的内存表示形式，因此可以跨 FFI 边界传递。
///
/// 在大多数情况下，引用可以像原始值一样使用。字段访问，方法调用和索引工作相同 (当然，要保留可变性规则)。另外，比较运算符透明地遵从引用对象的实现，从而允许将引用与拥有的值进行比较。
///
/// 引用具有附加的生命周期，代表借用有效的作用域。如果一个生命周期的代表作用域与另一个生命周期一样长或更长，则将其称为 "outlive"。`'static` 生命周期是最长的生命周期，它代表程序的总生命周期。
/// 例如，字符串字面量具有 `'static` 生命周期，因为文本数据嵌入到程序的二进制文件中，而不是嵌入在需要动态管理的分配中。
///
/// `&mut T` 相同的引用类型可以将引用自由地强制为 `&T`，较长生命周期的引用可以自由地强制为 `&T`。
///
/// 通过地址引用相等，而不是比较所指向的值，是通过 [`ptr::eq`] 通过隐式引用指针强制和裸指针相等来实现的，而 [`PartialEq`] 则是对值进行比较。
///
/// ```
/// use std::ptr;
///
/// let five = 5;
/// let other_five = 5;
/// let five_ref = &five;
/// let same_five_ref = &five;
/// let other_five_ref = &other_five;
///
/// assert!(five_ref == same_five_ref);
/// assert!(five_ref == other_five_ref);
///
/// assert!(ptr::eq(five_ref, same_five_ref));
/// assert!(!ptr::eq(five_ref, other_five_ref));
/// ```
///
/// 有关如何使用引用的更多信息，请参见 [the book's section on "References and Borrowing"][book-refs]。
///
/// [book-refs]: ../book/ch04-02-references-and-borrowing.html
///
/// # Trait 实现
///
/// 对于所有 `&T` 都实现了以下 traits，无论其引用的类型是什么:
///
/// * [`Copy`]
/// * [`Clone`] \(请注意，如果存在，这不会遵循 T 的 `Clone` 实现! )
/// * [`Deref`]
/// * [`Borrow`]
/// * [`Pointer`]
///
/// [`Deref`]: ops::Deref
/// [`Borrow`]: borrow::Borrow
/// [`Pointer`]: fmt::Pointer
///
/// `&mut T` 引用除了 `Copy` 和 `Clone` (以防止创建多个同时可变借用) 之外，还获得以下所有内容，以及以下内容，无论其引用的类型是什么:
///
/// * [`DerefMut`]
/// * [`BorrowMut`]
///
/// [`DerefMut`]: ops::DerefMut
/// [`BorrowMut`]: borrow::BorrowMut
///
/// 如果基础 `T` 也实现了 trait，则在 `&T` 上实现以下 traits:
///
/// * [`std::fmt`] 中的所有 traits ([`Pointer`] 和 [`fmt::Write`] 除外)
/// * [`PartialOrd`]
/// * [`Ord`]
/// * [`PartialEq`]
/// * [`Eq`]
/// * [`AsRef`]
/// * [`Fn`] \(此外，如果使用 `T: Fn`，则引用 `&T` 和 [`FnOnce`])
/// * [`Hash`]
/// * [`ToSocketAddrs`]
///
/// [`std::fmt`]: fmt
/// ['Pointer`]: fmt::Pointer
/// [`Hash`]: hash::Hash
/// [`ToSocketAddrs`]: net::ToSocketAddrs
///
/// `&mut T` 引用如果 `T` 实现了 trait，则获得除 `ToSocketAddrs` 之外的所有上述内容:
///
/// * [`AsMut`]
/// * [`FnMut`] \(此外，如果 `T: FnMut` 引用 `&mut T`，则获得 [`FnOnce`])
/// * [`fmt::Write`]
/// * [`Iterator`]
/// * [`DoubleEndedIterator`]
/// * [`ExactSizeIterator`]
/// * [`FusedIterator`]
/// * [`TrustedLen`]
/// * [`Send`] \(请注意，如果使用 `T: Sync`，则 `&T` 引用仅获得 `Send`)
/// * [`io::Write`]
/// * [`Read`]
/// * [`Seek`]
/// * [`BufRead`]
///
/// [`FusedIterator`]: iter::FusedIterator
/// [`TrustedLen`]: iter::TrustedLen
/// [`Seek`]: io::Seek
/// [`BufRead`]: io::BufRead
/// [`Read`]: io::Read
///
/// 请注意，由于采用了调用解引用强制多态方法，只需调用 trait 方法就可以像处理引用一样，也可以使用其拥有的值! 这里描述的实现是针对泛型上下文的，其中最终类型 `T` 是类型参数或本地未知。
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_ref {}

#[doc(primitive = "fn")]
//
/// 函数指针，例如 `fn(usize) -> bool`。
///
/// *另请参见 traits [`Fn`]，[`FnMut`] 和 [`FnOnce`]。*
///
/// [`Fn`]: ops::Fn
/// [`FnMut`]: ops::FnMut
/// [`FnOnce`]: ops::FnOnce
///
/// 函数指针是指向 *code* 的指针，而不是数据。它们可以像函数一样被调用。
/// 像引用一样，函数指针除其他外被假定为非 null，因此，如果您想在 FFI 上传递函数指针并能够容纳 null 指针，请使 `Option<fn()>` 类型具有所需的签名。
///
///
/// ### Safety
///
/// 普通函数指针是通过强制转换不能捕获环境的普通函数或闭包而获得的:
///
/// ```
/// fn add_one(x: usize) -> usize {
///     x + 1
/// }
///
/// let ptr: fn(usize) -> usize = add_one;
/// assert_eq!(ptr(5), 6);
///
/// let clos: fn(usize) -> usize = |x| x + 5;
/// assert_eq!(clos(5), 10);
/// ```
///
/// 除了根据其签名而有所不同外，函数指针还具有两种形式: 安全和不安全。
/// 普通 `fn()` 函数指针只能指向安全函数，而 `unsafe fn()` 函数指针可以指向安全或不安全函数。
///
/// ```
/// fn add_one(x: usize) -> usize {
///     x + 1
/// }
///
/// unsafe fn add_one_unsafely(x: usize) -> usize {
///     x + 1
/// }
///
/// let safe_ptr: fn(usize) -> usize = add_one;
///
/// // ERROR: 不匹配的类型: 预期正常 fn，发现不安全 fn let bad_ptr: fn(usize) -> usize=add_one_unsafely;
/////
///
/// let unsafe_ptr: unsafe fn(usize) -> usize = add_one_unsafely;
/// let really_safe_ptr: unsafe fn(usize) -> usize = add_one;
/// ```
///
/// ### ABI
///
/// 最重要的是，函数指针可以根据它们使用的 ABI 有所不同。这是通过在类型之前添加 `extern` 关键字，然后是所涉及的 ABI 来实现的。
/// 默认的 ABI 是 "Rust"，即 `fn()` 是与 `extern "Rust" fn()` 完全相同的类型。
/// 指向带有 C ABI 的函数的指针的类型为 `extern "C" fn()`。
///
/// `extern "ABI" { ... }` 块使用 ABI "ABI" 声明函数。此处的默认值为 "C"，即，在 `extern {...}` 块中声明的函数具有 "C" ABI。
///
/// 有关更多信息和受支持的 ABI 列表，请参见 [the nomicon's section on foreign calling conventions][nomicon-abi]。
///
/// [nomicon-abi]: ../nomicon/ffi.html#foreign-calling-conventions
///
/// ### 可变函数
///
/// "C" 或 "cdecl" ABI 的 Extern 函数声明也可以 *variadic*，允许使用可变数量的参数来调用它们。普通的 Rust 函数，即使是 `extern "ABI"` 的函数，也不能可变。
/// 有关更多信息，请参见 [关于可变参数函数的 nomicon 部分][nomicon-variadic]。
///
/// [nomicon-variadic]: ../nomicon/ffi.html#variadic-functions
///
/// ### 创建函数指针
///
/// 如果 `bar` 是函数的名称，则表达式 `bar`*不是* 函数指针。相反，它表示唯一标识函数 `bar` 的无法命名类型的值。
/// 该值的大小为零，因为该类型已经标识了该函数。
/// 这样做的好处是 "calling" 值 (实现 `Fn*` traits) 不需要动态分配。
///
/// 零大小的类型 *强制* 到常规函数指针。例如:
///
/// ```rust
/// use std::mem;
///
/// fn bar(x: i32) {}
///
/// let not_bar_ptr = bar; // `not_bar_ptr` 大小为零，唯一标识 `bar`
/// assert_eq!(mem::size_of_val(&not_bar_ptr), 0);
///
/// let bar_ptr: fn(i32) = not_bar_ptr; // 强制转换为函数指针
/// assert_eq!(mem::size_of_val(&bar_ptr), mem::size_of::<usize>());
///
/// let footgun = &bar; // 这是对标识 `bar` 的零大小类型的共享引用
/// ```
///
/// 最后一行显示 `&bar` 也不是函数指针。相反，它是特定于函数的 ZST 的引用。当 `bar` 是一个函数时，`&bar` 基本上不是您想要的。
///
/// ### Traits
///
/// 函数指针实现以下 traits:
///
/// * [`Clone`]
/// * [`PartialEq`]
/// * [`Eq`]
/// * [`PartialOrd`]
/// * [`Ord`]
/// * [`Hash`]
/// * [`Pointer`]
/// * [`Debug`]
///
/// [`Hash`]: hash::Hash
/// [`Pointer`]: fmt::Pointer
///
/// 由于 Rust 的类型系统中的临时限制，这些 traits 仅在 `"Rust"` 和 `"C"` ABI 上使用不超过 12 个参数的函数上实现。未来，这可能会改变。
///
/// 另外，具有 *any* 签名，ABI 或 safety 的函数指针是 [`Copy`]，并且所有 *safe* 函数指针都实现 [`Fn`]，[`FnMut`] 和 [`FnOnce`]。之所以可行，是因为这些 traits 是编译器特有的。
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_fn {}