Rust

Rust的registry索引原始设计十分病态:
它是一个构建在Git仓库上的平面文件数据库, 实际的数据文件是NDJSON格式.
这项莫明其妙的设计导致:

• registry服务不仅需要操作Git仓库, 还需要向外暴露Git仓库.
  这为实施替代品增添了很多不必要的麻烦, 并且引入了很多决策问题.
• cargo为了下载软件包, 需要克隆Git仓库, 而不是简单查询服务器获得结果.

RFC2789引入了基于HTTP静态文件服务器的registry来解决registry早期设计的缺陷,
但相关实现(https://github.com/rust-lang/cargo/pull/8890)还没有就位,
并且与身份验证相关的RFC3139还没有合并.

https://github.com/rust-lang/cargo/wiki/Third-party-registries

以下内容于Rust 2018淘汰:

• extern crate
• #[macro_use]

在Rust 2018里, 允许用户在模块的上一级文件夹中使用与模块同名的rs文件替代mod.rs,
如此设计是因为mod.rs文件对文本编辑器不友好(多个mod.rs文件难以区分).
普遍认为Rust 2015的目录结构更加"内聚", 所以不建议使用Rust 2018新增的目录结构.

将模块暴露给外部.

尽管名称有一定的迷惑性, 但它的功能是使用模块的同时将模块内容再次导出.

pub(crate), 将相应内容暴露给整个crate, 这在库开发中很常用, 因为"向crate以外隐藏细节, 但又允许在crate内使用"是很常见的需求.
pub(super), pub(self) 是 pub(in super) 和 pub(in self) 的语法糖.
pub(self) 没有实际意义, 因为它相当于"仅当前模块内部可见".

cargo访问私有Git仓库时通过ssh-agent进行认证, 因此必须启用ssh-agent:

# 启动ssh-agent, 并执行ssh-agent的返回值:
# SSH_AUTH_SOCK=/tmp/ssh-xxxxx/agent.xxxxxx
# 作用是将sock地址赋值给环境变量SSH_AUTH_SOCK, 以供其他程序访问.
eval `ssh-agent`
# 加载本地的ssh凭证
ssh-add

这同样能用来改变变量的修饰符:

let mut v = Vec::new();
let v = v;
// 反之亦然
let v = Vec::new();
let mut v = v;

变量遮蔽不会导致被遮蔽变量的生命周期提前结束.

Rust中的变量在默认情况下是不可变的.
如果需要让其可变, 必须加上 mut 修饰符.

绑定到下划线上的内存会立即调用析构函数(被销毁).

const声明的常量很可能会被编译器优化为内联值.

隐式类型转换通常只发生在智能指针上:

• &String 会转换为 &str
• &Vec<i32> 会转换为 &[i32]
• &Box<Chessboard> 会转换为 &Chessboard.

• true
• false

char表示任何一个unicode字符值, 占用4个字节的内存空间.

let love = 'c';
let c1 = '\n';
let c2 = '\x7f';
let c3 = '\u{7FFF}';

Rust的整数类型由类型定义其占用的内存空间, 而不是像C类语言那样由编译器定义类型的内存空间.

pointer size会根据平台改变实际的类型,
在32位平台上, usize是u32, 在64位上, usize是u64.
标准库和类型推导都倾向于使用pointer size而不是具体的类型.

let var1: i32 = 32;
let var2: i32 = 0xFF;
let var3: i32 = 0o55;
let var4: i32 = 0b1001;
let var5 = 0x_1234_ABCD; // 任意添加_以增强可读性
let var6 = 123usize; // 指定字面量类型
let var7 = 32; // 默认为i32类型
9_i32.pow(3); // 直接在字面量上调用函数

Rust使用IEEE 754-2008标准的浮点数, 分为 f32 和 f64 两种.

let f1 = 123.0f64;
let f2 = 0.1f64;
let f3 = 0.1f32;
let f4 = 12E+99_f64;
let f5: f64 = 2;

struct Color(i32, i32, i32);
struct Color {
    0: i32,
    1: i32,
    2: i32,
}
// 用来创造独立的类型
fn main() {
    struct Inches(i32);
    fn f(value: Inches) {}
    let v: i32 = 0;
    f(v); // 编译不通过, 因为Inches和i32不是一个类型, 且Rust不允许隐式类型转换
}

枚举可以用来表示JSON数据类型.

enum Json {
    Null,
    Boolean(bool),
    Number(f64),
    String(String),
    Array(Vec<Json>),
    Object(Box<HashMap<String, Json>>)
}

enum BinaryTree<T> {
    Empty,
    NonEmpty(Box<TreeNode<T>>)
}
struct TreeNode<T> {
    element: T,
    left: BinaryTree<T>,
    right: BinaryTree<T>
}

Rust标准库中的Result和Option就是enum类型.

enum Result<T, E> {
    Ok(T),
    Err(E)
}
enum Option<T> {
    None,
    Some(T),
}

除非使用引用类型, 否则Rust中的数组赋值默认是clone.

let xs: [i32; 5] = [1, 2, 3, 4, 5];
let xs: [i32; 500] = [0; 500]; // 批量初始化
let xs: [i32; 0] = []; // 空数组
// 多维数组 
let xs: [[i32; 2]; 3] = [[0, 0], [0, 0], [0, 0]];

Rust中的数组索引访问会带有运行时的边界检查, 索引访问的性能不如C/C++.
使用迭代器访问时则不会有边界检查.

for (index, value) in v.iter().enumerate() {
    ...
}

Vec的元素数量超过其缓冲区容量时, 会创建一个比原来大一倍的新缓冲区.

在结构体中使用 &str 时, 需要显式声明其生命周期参数.
这会让编码变得非常痛苦, 因此一些人倾向于在结构体里使用 String.

let s: &str = "Hello"
// 由于字符串使用了utf-8变长编码, 字符所处的内存位置不能直接得到.
// Rust里按索引取字符需要这样写:
s.chars().nth(n);
// 原始字符串
// r之后可以添加任意数量的井号(#), 字符串末端需要以相同数量的井号结束, 从而允许在原始字符串里输入双引号(").
let path = r"C:\Program Files\Rust"; 
// 字符串连接
let new_str = &str + &str; // 反直觉的是, 这在Rust里会报错.
// 解决方案: 创建一个String作为新字符串的容器
let mut new_string = String::new();
new_string.push_str(s);
new_string.push_str(s);
let new_str = new_string.as_str(); // 转换为&str

String 可以扩容, 其内部实现类似于 Vec<u8> 类型.

let mut s: String = String::from("Hello");
s.push(' ');
s.push_str("World.");
s.as_str(); // 转换为&str类型

• String 是一种类似于 Vec 的动态字符串类型, 位于堆, 可以从中得到切片视图 &str.
• &str 是一个指向内存中数据的指针/切片视图(C语言的 char*).
  指向的地方可以是 string.as_str() (指向堆),
  可以是在创建时就知道其长度的字面量 &str (指向栈),
  也可以是 &'static str (指向程序的静态存储, 静态存储在程序运行时加载进内存).

if本身是一种表达式, 相当于三元运算符.

let x: i32 = if condition { 1 } else { 2 };

enum Direction {
    East, West, South, North
}
fn print(x: Direction) {
    match x {
        Direction::East => { ... }
        Direction::West => { ... }
        Direction::South => { ... }
        Direction::North => { ... }
    }
}

match x {
    i if i > 5 => ...,
    i if i <= 5 => ...,
    _ => unreachable!(), // 由于编译器不懂得数学运算, 因此需要手动提示编译器
}

match x {
    '0' ... '9' => read_number(),
    'a' ... 'z' => read_word(),
    ' ' | '\t' | '\n' => read_whitespace(),
    _ => skip()
}

match x {
    ref r => ..., // 用ref关键字表示匹配的是引用而不是值, 从而避免所有权转移
}

enum OptionalInt {
    Value(i32),
    Missing,
}
let x = OptionalInt::Value(5);
match x {
    // 通过if表达式强化变体的条件匹配
    OptionalInt::Value(i) if i > 5 => ...,
    // `..`表示不在乎内容是什么
    OptionalInt::Value(..) => ...,
    OptionalInt::Missing => ...,
}

一种语法糖, 直接将匹配到的右值绑定到左值代表的变量上.

// 原始代码
match self.get_selection() {
    Shape::Rect(top_left, bottom_right) =>
        optimized_paint(&Shape::Rect(top_left, bottom_right)),
    _ => // ...
}
// 用@模式简写
match self.get_selection() {
    rect @ Shape::Rect(..) =>
        optimized_paint(&rect),
    _ => // ...
}

无限循环, 之所以存在单独的loop关键字, 是为了方便编译器优化.

loop {
    continue;
    break;
}
// 带有label的循环
'a: loop {
    'b: loop {
        break 'a;
        continue 'a;
    }
}

while condition {
    ...
}
while let Some(x) = optVal {
}

Rust没有C类的for循环, 只提供for-each.

let array = &[1, 2, 3, 4, 5]; // 一个可迭代对象
for i in array {
    println!("The number is {}", i);
}
// 用语法题生成一个Range, Range是可迭代的
for i in 1..10 {
    println!("The nubmer is {}", i);
}

在将trait作为约束使用这件事上, dyn前缀可以解决相同的问题, 但dyn解决此问题的方法不同:
dyn会在运行时导致动态分派(dynamic dispatch), 而泛型只是编译时生成相应的代码而已.
因此, 使用dyn比使用泛型的成本要高得多.

切片是最常见的不具有此特型的结构.

由于编译器难以跟踪基于索引的所有权转移(例如只转移其中的一个元素), 编译器会直接以编译错误拒绝掉相关代码.
因此, 基于索引的访问几乎总是需要事先借用(取得的是引用而不是所有权).

函数的 最佳实践 是 将参数类型视作函数是否要求所有权的提示:

• 通过 &T 暗示函数不需要相关参数的所有权, 从而避免传参时需要复制所造成的成本.
• 通过 T 暗示函数需要相关参数的所有权.

常见于在一个代码块里多次使用一个没有实现copy特型的数据类型的时候:
由于没有实现copy特型, 在第一次操作此数据类型时,
由于某种原因发生了所有权转移(比如作为函数参数传递), 所有权在转移之后没有归还,
导致之后的代码不能获得此数据类型的所有权.

• 数字
• 字符
• bool

例子:

• &T 转换为具有所有权的 T
• &[T] 转换为具有所有权的 Vec<T>

Box的一些使用场景:

• 需要确保不会发生复制语义.
• 需要将数据存放在堆而不是栈上.
  除非必要(例如栈的大小不够用, 或需要超越栈的生命周期), 否则一般不会将数据移动到堆, 因为栈和堆有很大的性能差异:
  栈非常频繁地被使用, 一般会被映射到CPU缓存上, 因此堆的性能会远不如栈的性能.

智能指针, 带有总大小和元素个数大小的数据.

utf8字符序列的指针.

• Cell
• RefCell

• Mutex
• RwLock
• Atomic*

Rust里能在多线程使用的类型必须具有Sync或Send约束, 否则会出现编译错误.

有析构函数的类型被编译器禁止拥有Copy特型.

手写生命周期参数的主要目的是让一个变量/参数/成员可以与其相关的主体共享同一个生命周期参数,
从而让编译器放宽限制.
需要注意的是, 生命周期参数总是意味着"临时借用"的语义(这是编译器持续追踪它的原因),
然而, 一些场景显然并不适用这种语义:
例如, 大多数结构体在语义上都不适合"借用"来自外部的变量, 而是应该自己"拥有"这些变量,
这种情况下, 最好用不需要生命周期参数的方式重构它.

// 函数
fn select<'a>(arg1: &'a i32, arg2: &'a i32) -> &'a i32 {
    if *arg1 > *arg2 { arg1 } else { arg2 }
}
// 类型
struct Test<'a> {
    member: &'a str
}
impl<'t> Test<'t> {
    fn test<'a>(&self, s: &'a str) {}
}

// Debug是可选的, 用于提供人类可读的错误描述
#[derive(Debug)]
enum GenError {
    Io(io::Error),
    Parse(num::ParseIntError),
}
type GenResult<T> = Result<T, GenError>;

通过From特型来实现"其他类型错误的转换", 省去编写手动转换每个错误的样本代码.

impl From<io::Error> for GenError {
    fn from(err: io::Error) -> {
        GenError::Io(err)
    }
}
impl From<num::ParseIntError> for GenError {
    fn from(err: num::ParseIntError) -> GenError {
        GenError::Parse(err)
    }
}

该设计的缺陷在于, 错误处理方可能不知道向下转换时可能的错误类型, 或者无法访问可能的错误类型.

// 所有标准库里的错误类型都可以隐式转换为Box<std::error::Error>, 利用这一点, 可以将它作为通用错误类型使用
type GenError = Box<dyn std::error::Error>;
// 一种使用GenError的新型Result
type GenResult<T> = Result<T, GenError>;
// 当遇到GenError时, 处理程序可以通过downcast_ref转换为具体错误:
if let Some(err) = gen_err.downcast_ref::<MyError>() {
    // ...
}

? 操作符之前, 一种处理错误的风格是使用标准库里的 try! 宏, ? 操作符取代了它的作用.

该库提供了一个 failure::Fail, 它之后被标准库错误(std::error::Error)取代.

围绕标准库错误建立的failure继任者.

围绕标准库错误建立的宏.