14 KiB
深入Rust类型
弱弱的、不负责任的说，Rust的学习难度之恶名，可能有一半来源于Rust的类型系统，而其中一半的一半则来自于本章节的内容。在本章，我们将重点学习如何创建自定义类型，以及了解何为动态大小的类型。
newtype
何为newtype? 简单来说，就是使用元组结构体的方式将已有的类型包裹起来:struct Meters(u32);, 那么此处Meters就是一个newtype。
为何需要newtype？Rust这多如繁星的Old类型满足不了我们吗？这是因为：
- 自定义类型可以让我们给出更有意义和可读性的类型名，例如与其使用
u32作为距离的单位类型，我们可以使用Meters，它的可读性要好的多 - 对于某些场景，只有newtype可以很好的解决
- 隐藏内部类型的细节
一箩筐的理由～～ 让我们先从第二点讲起。
为外部类型实现外部特征
在之前的章节中，我们有讲过如果在外部类型上实现外部特征必须使用newtype的方式，否则你就得遵循孤儿规则：要为类型A实现特征T，那么A或者T必须有一个在当前的作用范围内。
例如, 如果想使用println!("{}",v)的方式去格式化输出一个动态数组Vec，以期给用户提供更加清晰可读的内容，那么就需要为Vec实现Display特征，但是这里有一个问题：Vec类型定义在标准库中，Display亦然， 这时就可以祭出大杀器newtype来解决：
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}]", self.0.join(", "))
}
}
fn main() {
let w = Wrapper(vec![String::from("hello"), String::from("world")]);
println!("w = {}", w);
}
如上所示，使用元组结构体语法struct Wrapper(Vec<String>)创建了一个newtype Wrapper, 然后为它实现Display特征，最终实现了对Vec动态数组的格式化输出。
更好的可读性及类型异化
首先，更好的可读性不等于更少的代码(如果你学过scala，相信会深有体会)，其次下面的例子只是一个示例，未必能体现出更好的可读性：
use std::ops::Add;
use std::fmt;
struct Meters(u32);
impl fmt::Display for Meters {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "目标地点距离你{}米", self.0)
}
}
impl Add for Meters {
type Output = Self;
fn add(self, other: Meters) -> Self {
Self(self.0 + other.0)
}
}
fn main() {
let d = calculate_distance(Meters(10), Meters(20));
println!("{}",d);
}
fn calculate_distance(d1: Meters,d2: Meters) -> Meters {
d1 + d2
}
上面代码创建了一个newtype Meters，为其实现Display和Add特征，接着对两个距离进行求和计算，最终打印出该距离:
目标地点距离你30米
事实上，除了可读性外，还有一个极大的优点：如果给calculate_distance传一个其它的类型，例如struct MilliMeters(u32);,该代码将无法编译。尽管Meters和MilliMeters都是对u32类型的简单包装，但是它们是不同的类型！
隐藏内部类型的细节
众所周知，Rust的类型有很多自定义的方法，假如我们把某个类型传给了用户，但是又不想用户调用这些方法，就可以使用newtype:
struct Meters(u32);
fn main() {
let i: u32 = 2;
assert_eq!(i.pow(2),4);
let n = Meters(i);
// 下面的代码将报错，因为`Meters`类型上没有`pow`方法
// assert_eq!(n.pow(2),4);
}
不过需要偷偷告诉你的是，这种方式实际上是掩耳盗铃，因为用户依然可以通过n.0.pow(2)的方式来调用内部类型的方法:)
类型别名(Type Alias)
除了使用newtype，我们还可以使用一个更传统的方式来创建新类型: 类型别名
type Meters = u32
嗯，不得不说，类型别名的方式看起来比newtype顺眼的多，而且跟其它语言的使用方式几乎一致，但是：
类型别名并不是一个独立的全新的类型，而是某一个类型的别名，因此编译器依然会把Meters当u32来使用：
type Meters = i32;
let x: u32 = 5;
let y: Meters = 5;
println!("x + y = {}", x + y);
上面的代码将顺利编译通过，但是如果你使用newtype模式，该代码将无情报错，简单做个总结：
- 类型别名仅仅是别名，只是为了让可读性更好，并不是全新的类型，
newtype才是！ - 类型别名无法实现为外部类型实现外部特征等功能，而
newtype可以
类型别名除了让类型可读性更好，还能减少模版代码的使用:
let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));
fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
// --snip--
}
fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
// --snip--
}
f是一个令人眼花缭乱的类型Box<dyn Fn() + Send + 'static>，如果仔细看，会发现其实只有一个Send特征不认识，Send是什么在这里不重要，你只需理解，f就是一个Box<dyn T>类型的特征对象，实现了Fn()和Send特征，同时生命周期为'static。
因为f的类型贼长，导致了后面我们在使用它时，到处都充斥这些不太优美的类型标注，好在类型别名可解君忧:
type Thunk = Box<dyn Fn() + Send + 'static>;
let f: Thunk = Box::new(|| println!("hi"));
fn takes_long_type(f: Thunk) {
// --snip--
}
fn returns_long_type() -> Thunk {
// --snip--
}
Bang! 是不是？！立刻大幅简化了我们的使用。 喝着奶茶、哼着歌、我写起代码撩起妹，何其快哉！
在标准库中，类型别名应用最广的就是简化Result<T,E>枚举。
例如在std::io库中，它定义了自己的Error类型：std::io::Error，那么如果要使用该Result就要用这样的语法：std::result::Result<T, std::io::Error>;，想象一下代码中充斥着这样的东东是一种什么感受？颤抖吧。。。
由于使用std::io库时，它的所有错误类型都是std::io::Error，那么我们完全可以把该错误对用户隐藏起来，只在内部使用即可，因此就可以使用类型别名来简化实现:
type Result<T> = std::result::Result<T, std::io::Error>;
Bingo, 这样一来，其它库只需要使用std::io::Result<T>即可替代冗长的std::result::Result<T, std::io::Error>类型.
更香的是，由于它只是别名，因此我们可以用它来调用真实类型的所有方法,甚至包括?符号！
!永不返回类型
在函数那章，曾经介绍过!类型：!用来说明一个函数永不返回任何值，当时可能体会不深，没事，在学习了更多手法后，保证你有全新的体验：
fn main() {
let i = 2;
let v = match i {
0..=3 => i,
_ => println!("不合规定的值:{}",i)
};
}
上面函数，会报出一个编译错误:
error[E0308]: `match` arms have incompatible types // match的分支类型不同
--> src/main.rs:5:13
|
3 | let v = match i {
| _____________-
4 | | 0..3 => i,
| | - this is found to be of type `{integer}` // 该分支返回整数类型
5 | | _ => println!("不合规定的值:{}",i)
| | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected integer, found `()` // 该分支返回()元类型
6 | | };
| |_____- `match` arms have incompatible types
原因很简单: 要赋值给v，就必须保证match的各个分支返回的值是同一个类型，但是上面一个分支返回数值、另一个分支返回元类型()，自然会出错。
既然println不行，那再试试panic
fn main() {
let i = 2;
let v = match i {
0..=3 => i,
_ => panic!("不合规定的值:{}",i)
};
}
神奇的事发生了，此处panic竟然通过了编译。难道这两个宏拥有不同的返回类型？
你猜的没错：panic的返回值是!，代表它决不会返回任何值，既然没有任何返回值，那自然不会存在分支类型不匹配的情况。
动态大小类型
读者大大们之前学过的几乎所有类型，都是固定大小的类型，包括集合Vec、String和HashMap等，而动态大小类型刚好与之相反: 编译器无法在编译期得知该类型值的大小，只有到了程序运行时，才能动态获知。对于动态类型，我们使用DST(dynamically sized types)或者unsized类型来称呼它。
上述的这些集合虽然底层数据可动态变化，感觉像是动态大小的类型。但是实际上，这些底层数据只是保存在堆上，在栈中还存有一个引用类型，该引用包含了集合的内存地址、元素数目、分配空间信息，通过这些信息，编译器对于该集合的实际大小了若指掌，因此它们依然是固定大小的类型。
现在给你一个挑战：想出一个动态类型。俺厚黑的说一句，估计大部分人都想不到这样的一个类型:P 。就连我，如果不是查询着资料在写，估计也一时半会儿想不到一个。
考虑一下这个类型：str，感觉有点眼生？是的，它既不是String动态字符串，也不是&str字符串切片，而是一个str。它是一个动态类型，同时还是String和&str的底层数据类型。 由于str是动态类型，因此它的大小直到运行期才知道，下面的代码会因此报错：
// error
let s1: str = "Hello there!";
let s2: str = "How's it going?";
// ok
let s3: &str = "on?"
Rust需要明确的知道一个特定类型的值占据了多少内存空间，同时该类型的所有值都必须使用相同大小的内存。如果Rust允许我们使用这种动态类型，那么这两个str值就需要占用同样大小的内存，这显然是不现实的: s1占用了12字节，s2占用了15字节，总不至于为了满足同样的内存大小，用空白字符去填补字符串吧？
所以，我们只有一条路走，那就是给它们一个固定大小的类型：&str。那么为何字符串切片&str就是固定大小呢？因为它的引用存储在栈上，具有固定大小(类似指针)，同时它指向的数据存储在堆中，也是已知的大小，再加上&str引用中包含有堆上数据内存地址、长度等信息，因此最终可以得出字符串切片是固定大小类型的结论。
与&str类似，String字符串也是固定大小的类型。
正是因为&str的引用有了底层堆数据的明确信息，它才是固定大小类型。假设如果它没有这些信息呢？那它也将变成一个动态类型。因此，将动态数据固定化的秘诀就是使用引用指向这些动态数据，然后在引用中存储相关的内存位置、长度等信息。
我们之前已经见过，使用Box将一个没有固定大小的特征变成一个有固定大小的特征对象，那能否故技重施，将str封装成一个固定大小类型？留个悬念先，我们来看看Sized特征。
Rust中最常见的
DST类型:str,[T],dyn Trait
Sized特征
既然动态类型的问题这么大，那么在使用泛型时，Rust如何保证我们的泛型参数是固定大小的类型呢？例如以下泛型函数：
fn generic<T>(t: T) {
// --snip--
}
该函数很简单，就一个泛型参数T，那么如果保证T是固定大小的类型？仔细回想下，貌似在之前的课程章节中，我们也没有做过任何事情去做相关的限制，那T怎么就成了固定大小的类型了？奥秘在于编译器自动帮我们加上了Sized特征：
fn generic<T: Sized>(t: T) {
// --snip--
}
在上面,Rust自动添加的特征约束T: Sized，表示泛型函数只能用于一切实现了Sized特征的类型上，而所有在编译时就能知道其大小的类型, 都会自动实现Sized特征，例如。。。。也没啥好例如的，你能想到的几乎类型都实现了Sized特征，除了上面那个坑坑的str，哦，还有特征。
每一个特征都是一个可以通过名称来引用的动态大小类型。因此如果想把特征作为具体的类型来传递给函数，你必须将其转换成一个特征对象：诸如&dyn Trait或者Box<dyn Trait>(还有Rc<dyn Trait>)这些引用类型。
现在还有一个问题：假如想在泛型函数中使用动态数据类型怎么办？可以使用?Sized特征(不得不说这个命名方式很Rusty，竟然有点幽默):
fn generic<T: ?Sized>(t: &T) {
// --snip--
}
?Sized特征用于表明类型T既有可能是固定大小的类型，也可能是动态大小的类型。还有一点要注意的是，函数参数类型从T变成了&T，因为T可能是动态大小的，因此需要用一个固定大小的指针(引用)来包裹它。
Box
在结束前，再来看看之前遗留的问题: 使用Box可以将一个动态大小的特征变成一个具有固定大小的特征对象，能否故技重施，将str封装成一个固定大小类型？
先回想下，章节前面的内容介绍过该如何把一个动态大小类型转换成固定大小的类型： 使用引用指向这些动态数据，然后在引用中存储相关的内存位置、长度等信息。
好的，根据这个，我们来一起推测。 首先，Box<str>使用了一个引用来指向str，嗯，满足了第一个条件。但是第二个条件呢？Box中有该str的长度信息吗？显然是No。那为什么特征就可以变成特征对象？其实这个还蛮复杂的，简单来说，对于特征对象，编译器无需知道它具体是什么类型，只要知道它能调用哪几个方法即可，因此编译器帮我们实现了剩下的一切。
来验证下我们的推测:
fn main() {
let s1: Box<str> = Box::new("Hello there!" as str);
}
报错如下：
error[E0277]: the size for values of type `str` cannot be known at compilation time
--> src/main.rs:2:24
|
2 | let s1: Box<str> = Box::new("Hello there!" as str);
| ^^^^^^^^ doesn't have a size known at compile-time
|
= help: the trait `Sized` is not implemented for `str`
= note: all function arguments must have a statically known size
提示的很清晰，不知道str的大小，因此无法对其使用Box进行封装.