Rust 擅长此事

• 编译后的代码拥有与 C/C++ 几乎同样的性能 , 在内存和能效方面甚至更强.
• 可以避免 C/C++ 存在 70% 的安全问题和绝大多数内存问题.
• 强类型系统可防止数据竞争, 带来「无畏并发」 (以及更多).
• 与 C 无缝衔接, 支持数十个平台 (基于 LLVM).
• 连续 6 年「最喜爱的语言」.
• 现代工具链: cargo (构建工作 正好能用), clippy (450+ 代码质量 lints), rustup (易用的工具链管理)).

你可能会遇到的问题

• 学习曲线陡峭¹. 其他场合下的“最佳实践”往往会被编译器教训一通(特别是内存方面).
• 缺少某些领域的 Rust-native 库, 目标平台(尤其是嵌入式)以及 IDE 功能.¹
• 比起其他语言中“类似的”代码编译时间更长.¹
• 没有正式语言规范, 影响在某些领域(如航空, 医疗等)的合法使用.
• 内部使用了 unsafe 的第三方库有可能会破坏安全性保证.

¹ 参见该 Rust 调查结果.

下载

• 从 rustup.rs 获取安装程序 (推荐用于任何平台)

IDE 编辑器

• IntelliJ (免费) 或者带有 IntelliJ Rust 功能的 CLion (收费).
• 安装了 rust-analyzer 插件的 Visual Studio Code.

模块化初学者资源

• 《Rust 语言之旅》(中文) - 一边讲解, 一边实时编码.
• Rust in Easy English - 用若干个例子和简单的英语解释了 60 多个概念. 可以用来练习英语.

另可参考常用文档. BK EX STD

作者按 💭 — 如果你从来没用过 Rust 最好还是先看看上面的教程, 本文后续章节对相关概念仅作简要说明, 不会深入讲解.

f32 的位表示^*:

说明:

同样, 对于 f64 类型, 这将类似于:

let s = "I ❤ Rust";
let t = "I ❤️ Rust";

基础

假设有一集合 struct Collection<T> {}.

• struct IntoIter<T> {} — 创建一个持有自定义迭代状态 (比如下标) 的结构体.
• impl Iterator for IntoIter {} — 实现能够产生元素的 Iterator::next().

共享和可变迭代器

• struct Iter<T> {} — 创建一个持有 &Collection<T> 的结构体用于共享迭代.
• struct IterMut<T> {} — 类似地, 但持有 &mut Collection<T> 用于可变迭代.
• impl Iterator for Iter<T> {} — 实现共享迭代.
• impl Iterator for IterMut<T> {} — 实现可变迭代.

另外, 建议实现如下方法以获取对应迭代器:

• Collection::iter(&self) -> Iter,
• Collection::iter_mut(&mut self) -> IterMut.

实现循环

• impl IntoIterator for Collection {} — 使得 for x in c {} 可用.
• impl IntoIterator for &Collection {} — 使得 for x in &c {} 可用.
• impl IntoIterator for &mut Collection {} — 使得 for x in &mut c {} 可用.

这里列出了在 format! 和类似命令中, 通过 trait Display "{}" STD 或 Debug "{:?}" STD 实现的类型转换 (并不全面):

简而言之, Debug 打印出详细信息; 而 特殊 类型需要特别指定如何转换到 ↑ Display.

格式化宏中的各参数指示器可以是 {}, {argument} 或后续下述基本语法:

{ [argument] ':' [[fill] align] [sign] ['#'] [width [$]] ['.' precision [$]] [type] }

// src/lib.rs (默认库入口点)

pub fn f() {}      // 根下的公共条目, 可被外部访问.

mod m {
    pub fn g() {}  // 根下非公开 (`m` 不公开), 
}                  // 所以 crate 外不可访问.

// src/my_module.rs (项目中任意文件)

fn f() -> u32 { 0 }

#[cfg(test)]
mod test {
    use super::f;           // 需要从父模块导入.
                            // 可以访问非公共成员.
    #[test]
    fn ff() {
        assert_eq!(f(), 0);
    }
}

// tests/sample.rs (例程测试样例)

#[test]
fn my_sample() {
    assert_eq!(my_crate::f(), 123); // 集成和性能测试对 crate 的依赖
}                                   // 与依赖第三方库是一样的. 因此仅可访问公开项.

// benches/sample.rs (性能测试样例)

#![feature(test)]   // #[bench] 依然是实验性的

extern crate test;  // 出于某些原因在 '18 版本仍需要.
                    // 虽然通常情况下可能不需要.

use test::{black_box, Bencher};

#[bench]
fn my_algo(b: &mut Bencher) {
    b.iter(|| black_box(my_crate::f())); // `black_box` 防止 `f` 被优化掉.
}

// build.rs (预编译脚本样例)

fn main() {
    // 通过 env 环境变量获取编译目标; 也可使用 `#[cfg(...)]`.
    let target_os = env::var("CARGO_CFG_TARGET_OS");
}

^*环境变量详见该表.

// src/lib.rs (过程宏默认入口)

extern crate proc_macro;  // 需要显式引入.

use proc_macro::TokenStream;

#[proc_macro_attribute]   // 此时可以通过 `#[my_attribute]` 使用
pub fn my_attribute(_attr: TokenStream, item: TokenStream) -> TokenStream {
    item
}

// Cargo.toml

[package]
name = "my_crate"
version = "0.1.0"

[lib]
proc-macro = true

Rust 有如下三种命名空间:

• 在给定作用域中（例如某个模块内），每个命名空间下只能有一个同名项，例如：
  • enum X {} 与 fn X() {} 可以共存
  • struct X; 与 const X 不能共存
• 使用 use my_mod::X; 时，所有名为 X 的项都会被导入。

由于命名惯例（例如按惯例 fn 与 mod 用小写）以及 常识（多数开发者不会把所有东西都叫 X），多数情况下你不必担心这些 种类。但在设计宏时，它们可能成为影响因素。

文档注释BK EX REF中的写法如下:

这些属性对整个 crate 或应用程序都生效:

这些属性主要用于控制相关代码:

Rust 工具链利用这些属性提升代码质量:

这些属性用于创建或者修饰宏:

这些属性用于条件编译:

⚠️ 注意：选项通常可设置多次，即同一键可出现多个值。可以预期 #[cfg(target_feature = "avx")] 与 #[cfg(target_feature = "avx2")] 同时为真。

预编译脚本可用的环境变量和输出配置.

类型构造器 — Vec<>

• Vec<u8> 是“字节向量”类型; Vec<char> 是“字符向量”类型, 但 Vec<> 是什么?

类型和类型构造

• Vec<> 为非类型, 不占内存, 也不会生成代码.
• Vec<> 为 类型构造器, 是“模板”或者“创建类型的表单”
  • 允许第三方通过参数构造特定类型,
  • 仅当声明 Vec<UserType> 时才成为真正的类型.

泛型参数 — <T>

• Vec<> 的参数常作 T 故有 Vec<T>.
• T “类型的变量名”可以特化为 Vec<f32>, S<u8>, …

类型和类型构造器

// S<> 是个带有参数 T 的类型构造器; 用户可以提供 T 的任意实际类型.
struct S<T> {
    x: T
}

// 实际使用中必须为 T 指定实际类型.
fn f() {
    let x: S<f32> = S::new(0_f32);
}

常量泛型 — [T; N] 与 S<const N: usize>

• 某些类型构造器不仅接受指定类型, 还接受 指定常量.
• [T; n] 构造出一个有 n 个 T 类型元素的数组.
• 自定义类型可声明为 MyArray<T, const N: usize>.

基于常量的类型构造器

let x: [u8; 4]; // "4 字节数组"
let y: [f32; 16]; // "16 浮点数组"

// `MyArray` 是个需要特定类型 `T` 和特定大小 `N` 的类型构造器.
struct MyArray<T, const N: usize> {
    data: [T; N],
}

约束（简单）— where T: X

• 如果 T 可以为任意类型, 那我们怎么确定能为它实现这么一个 Num<T>?
• 参数约束:
  • 限制了允许什么样的类型 (trait 约束) 或值 (常量约束 ?),
  • 然后就可以应用这些限制了!
• trait 约束像是一种“行为检查”:

// 类型仅能由某些实现了 `Absolute` 的 `T` 实现.
struct Num<T> where T: Absolute {
    ...
}

约束（复合）— where T: X + Y

struct S<T>
where
    T: Absolute + Dim + Mul + DirName + TwoD
{ ... }

• 过长的 trait 约束像是一种威胁.
• 实践中, 每个 + X 声明都会减少这里能用的类型.

为一类类型实现 — impl<>

impl<T> S<T> where T: Absolute + Dim + Mul {
    fn f(&self, x: T) { ... };
}

可以读作:

• 这里是对任意类型 T 一个实现 (即 impl <T> 部分),
• 该类型必须同时满足 Absolute + Dim + Mul 这些 trait 约束,
• 可以添加一个实现块 S<T>,
• 以及包含更多方法 …

可以将类如 impl<T> ... {} 的代码看作对一类行为的抽象实现. 尤其使得第三方透明地实例化与类型构造器如何实例化类似:

// 当编译器遇到如下代码时将会
// - 检查 `0` 和 `x` 是否满足 `T` 的要求
// - 创建两个版本的 `f`, 一个给 `char`, 另一个给 `u32`.
// - 并基于“一类实现”来提供
s.f(0_u32);
s.f('x');

一揽子实现 — impl<T> X for T { … }

也可以针对多种类型编写针对某“一类的实现”:

// 为任意已经实现过 ToHex 的类型实现 Serialize
impl<T> Serialize for T where T: ToHex { ... }

这称为一揽子实现.

→ 左边的类型总能根据该 impl 实现到右边 →

这样可以用一种模块化的方法为已经实现了其他接口的给定外部类型提供一种优雅的实现.

trait 参数 — trait<In> { type Out; }

注意某些 trait 会被“附加”多次, 而有些又只有一次?

为什么?

• trait 本身可以对两类 参数 做泛型：
  • trait From<I> {}
  • trait Deref { type O; }
• 还记得我们说过 trait 是类型的“成员列表”，并把该列叫做 Self 吗？
• 由此看来，参数 I（输入）和 O（输出）不过是该 trait 列表上更多的 列：

impl From<u8> for u16 {}
impl From<u16> for u32 {}
impl Deref for Port { type O = u8; }
impl Deref for String { type O = str; }

输入和输出参数

这里会有点绕,

• 任意输出 O 参数必须由输入参数 I 唯一确定,
• (同样地, 关系 X Y 会表现为一个函数),
• Self 作为输入.

一个更复杂的样例:

trait Complex<I1, I2> {
    type O1;
    type O2;
}

• 此处创建了一个具有关联类型的 Complex,
• 它有 3 个输入 (Self 也是输入) 和 2 两个输出, 可以表示为 (Self, I1, I2) => (O1, O2)

各种 trait 实现。最后一个对 (NiceMonster, u16, String) 无效，因为该输入组合已经唯一确定了输出。

trait 设计考量（抽象）

• 参数的选择 (输入还是输出) 仍然决定了谁会被允许加入成员:
  • I 参数允许“一类实现”转发给用户 (Santa),
  • O 参数必须由 trait 实现者确定 (Alice 或 Bob).

trait A<I> { }
trait B { type O; }

// 实现者将 (X, u32) 添加到 A.
impl A<u32> for X { }

// 实现者将一类 impl (X, ...) 添加到 A, 用户则可以特化之.
impl<T> A<T> for Y { }

// 实现者必须决定将指定入口 (X, O) 添加到 B.
impl B for X { type O = u32; }

Santa 通过提供他自己类型为 T 添加更多成员.

给定输入集合 (此处为 Self), 实现者必须预先选择 O.

trait 设计考量（示例）

参数选择取决于 trait 的作用.

无额外参数

trait Query {
    fn search(&self, needle: &str);
}

impl Query for PostgreSQL { ... }
impl Query for Sled { ... }

postgres.search("SELECT ...");

trait 作者假设:

• 实现者和用户都不允许自定义 API.

输入参数

trait Query<I> {
    fn search(&self, needle: I);
}

impl Query<&str> for PostgreSQL { ... }
impl Query<String> for PostgreSQL { ... }
impl<T> Query<T> for Sled where T: ToU8Slice { ... }

postgres.search("SELECT ...");
postgres.search(input.to_string());
sled.search(file);

trait 作者假设:

• 实现者可以为相同的 Self 类型提供多个自定义 API 实现,
• 用户来决定哪种 I 类型行为可用.

输出参数

trait Query {
    type O;
    fn search(&self, needle: Self::O);
}

impl Query for PostgreSQL { type O = String; ...}
impl Query for Sled { type O = Vec<u8>; ... }

postgres.search("SELECT ...".to_string());
sled.search(vec![0, 1, 2, 4]);

trait 作者假设:

• 实现者可以为 Self 类型自定义 API (但只有一种办法),
• 用户不需要也不应该能够影响指定 Self 的自定义.

如你所见, 对于函数而言 输入 或 输出 项都 不一定 (除非有必要) 是 I 或 O!

多个输入输出参数

trait Query<I> {
    type O;
    fn search(&self, needle: I) -> Self::O;
}

impl Query<&str> for PostgreSQL { type O = String; ... }
impl Query<CString> for PostgreSQL { type O = CString; ... }
impl<T> Query<T> for Sled where T: ToU8Slice { type O = Vec<u8>; ... }

postgres.search("SELECT ...").to_uppercase();
sled.search(&[1, 2, 3, 4]).pop();

如上例, 通常 trait 作者假设:

• 用户来决定哪种 I 类型行为可用,
• 对于给定的输入, 实现者需要自己确定输出类型.

动态大小 / 零大小类型

• 如果编译期能够知道用多少个字节表示, 那么类型 T 就是 Sized STD 的, u8 和 &[u8] 是有大小的, [u8] 则不是.
• 有大小 Sized 意味着存在 impl Sized for T {}. 这个会自动实现且也不能由用户实现.
• 非 Sized 的类型称为 动态大小类型 BK NOM REF (DST), 有时是 无大小的.
• 无数据的类型称为 零大小类型 NOM (ZST), 不分配空间.

?Sized

struct S<T> { ... }

• T 可为任意确定类型.
• 然而这里存在隐式约束 T: Sized, 故 S<str> 不可用.
• 可以改为 T : ?Sized 以取消该默认约束:

struct S<T> where T: ?Sized { ... }

泛型与生命周期 — <'a>

• 生命周期与类型参数使用方法^*类似:
  • 用户必须为特定类型指定 'a (编译器会在方法中提供帮助),
  • 由于 Vec<f32> 和 Vec<u8> 是不同的类型, 故记为 S<'p> 和 S<'q>,
  • 这意味着你不能仅分配类型 S<'a> 的值而不管 S<'b> (异常: 生命周期的“子类型”关系, 如 'a 长于 'b).

• 'static 是仅有的 类型空间 中的具名生命周期.

// `'a 是这里的自由参数 (用户可以在任意生命周期上使用)
struct S<'a> {
    x: &'a u32
}

// 非泛型代码中, 'static 是这里仅有的能使用的具名声明周期.
let a: S<'static>;

// 非泛型代码中我们无需指定 'a 并使得 Rust 通过右值自动推断出 'a.
let b: S;

备忘 / TODO：这个类比似乎有点问题——若 S<'a> 之于 S<'static> 就像 S<T> 之于 S<u32>，那 'static 就会是一种 类型；可那种类型的值又是什么？

fn f(x: A) -> B {
    x.into()
}

从 A 得到 B 最常用的方式。一些 trait 提供了规范的、可由用户计算的类型关系：

fn f(x: A) -> B {
    x as B
}

若转换 相对明显 但可能出问题，可用关键字 as 转换类型。NOM