【Rust 笔记】09-特型与泛型
09 - 特型与泛型
-
Rust 的多态性：
- 特型（trait）
- 泛型（generic）
-
特型：Rust 对接口或抽象基类的实现。
-
如下写字节的特型
std::io::Write：trait Write { fn write(&mut self, buf: &[u8]) -> Result<usize>; fn flus(&mut self) -> Result<()>; fn write_all(&mut self, buf: &[u8]) -> Result<()> { ... } ... } -
内置特型是 Rust 语言为操作符重载及其其他特性提供的钩子（hook）。
-
-
泛型：泛型函数或类型可以搭配很多种不同类型的值使用。
/// 给定两个值，取出较小的值 fn min<T: Ord>(value1: T, value2: T) -> T { if value1 <= value2 { value1 } else { value2 } }<T: Ord>代表min可以使用实现Ord特型的任意类型参数 T；- 声明
T: Ord叫做绑定。
9.1 - 使用特型
- 特型是一种任何类型都可以选择支持或不支持的特性。常见的特型：
- 实现
std::io::Write的值可以执行写字节操作； - 实现
std::iter::Iterator的值可以产生值的序列； - 实现
std::clone::Clone的值可以在内存中克隆自身； - 实现
std::fmt::Debug的值可以使用println!()的{:?}格式说明符打印出来。
- 实现
- 常见的标准库实现了上述特型：
std::fs::File实现了Write特型，可以将字节写入本地文件。std::net::TcpStream则是将字节写入网络连接。Vec<u8>同样实现了Write。在字节向量上每次调用.write()，都可以在向量末尾追加一些数据。Range<i32>实现了Iterator特型，与切片、散列表等相关的其他爹大气类型也实现了这个特型。- 除了
TcpStream这种不仅仅表示内存中数据的类型外，大多数标准库类型都实现了Clone特型。 - 大多数标准库都支持
Debug特型。
- 特型本身必须在作用域中。
- 可以使用特型给任何类型添加新方法。
Clone和Iterator方法，默认一直在作用域中。它们是标准前置模块的一部分，Rust 会自动将其导入到所有模块中。- 标准前置模块，本质是一个特型集合。
9.1.1 - 特型目标
-
Rust 有两种方式使用特型编写多态化代码：特型目标与泛型。
-
Rust 不允许声明
Write类型的变量：因为变量的大小必须在编译时就知道，而实现Write的类型可以是任意大小。 -
特型目标：指向一个特型类型（如下面的
writer）的引用，具有引用的共同性：指向某个值，有生命期，可以是mut或共享引用。let mut buf: Vec<u8> = vec![]; let writer: &mut Write = &mut buf; -
特型目标的不同之处：Rust 在编译时通常不知道引用目标的类型。
9.1.2 - 特型目标的内存布局
-
特型目标是一个胖指针，包含指向值的指针和指向表示该值类型的表的指针。每个特型目标都占用两个机器字。
-
Rust 在必要时会自动将普通引用转换为特型目标。
let mut local_file = File::create("hello.txt")?; // &mut local_file的类型是&mut File say_hello(&mut local_file)?; // say_hello的参数类型是&mut Write
9.1.3 - 泛型函数
-
如下
say_hello()泛型函数，接收一个特型目标作为参数。fn say_hello<W: Write>(out: &mut W) -> std::io::Result<()> { out.write_all(b"hello world\n")?; out.flush() }<W: Write>是类型参数（type parameter），表示实现了Write特型的某种类型。- 类型参数通常是一个大写字母。
-
泛型函数可以有多个类型参数：
fn run_query<M: Mapper + Serialize, R: Reducer + Serialize>(data: &DataSet, map: M, reduce: R) -> Results { ... }-
上述代码的绑定显得比较长，可以使用
where关键字，将上述代码结构清晰的表述出来：fn run_query<M, R>(data: &DataSet, map: M, reduce: R) -> Results where M: Mapper + Serialize, R: Reducer + Serialize { ... } -
这样的类型参数
M和R仍然是提前声明，但是绑定转移到了后面。 -
where子句也适用于泛型结构体、枚举、类型别名和方法等，任何允许使用绑定的地方。
-
-
泛型函数可以同时拥有生命期参数和类型参数。生命期参数写在前面：
fn nearest<'t, 'c, P>(target: &'t P, candidates: &'c [P]) -> &'c P where P: MeasureDistance { ... } -
除了函数外，其他特性也支持泛型：
-
泛型结构体
-
泛型枚举
-
泛型方法，不管定义该方法的类型是不是泛型的。
impl PancakeStack { fn push<T: Topping>(&mut self, goop: T) -> PancakeResult<()> { ... } } -
泛型类型别名
type PancakeResult<T> = Result<T, PancakeError>; -
泛型特型
-
-
绑定、
where子句、生命期参数等，可以适用于上述所有泛型特性项。
9.1.4 - 使用场景
- 定义一个混合类型的值，使之全部集合在一起，推荐使用特性目标。
- 使用特型目标可以减少编译后的总代码量，防止出现代码膨胀（code bloat），适用于制作微控制器。
- 泛型相比特型目标的优势：
- 速度：消除了动态查找的时间；
- 并非所有特型都支持特型目标。如静态方法只对泛型有效，完全没有考虑特型对象。
9.2 - 定义和实现特型
-
定义特型：给它命名并列出特型方法的类型签名：
trait Visible { fn draw(&self, canvas: &mut Canvas); fn hit_test(&self, x: i32, y: i32) -> bool; } -
实现特型，使用
impl TraitName for Type语法：impl Visible for Broom { fn draw(&self, canvas: &mut Canvas) { for y in self.y - self.height - 1 .. self.y { canvas.write_at(self.x, y, '|'); } canvas.write_at(self.x, self.y, 'M'); } fn hit_test(&self, x: i32, y: i32) -> bool { self.x == x && self.y - self.height - 1 <= y && y <= self.y } }-
特型
impl中定义的，都是特型的特性。 -
如果要添加一个支持
Broom::draw()的辅助方法，那么就在单独的impl块中定义它：impl Broom { fn broomstick_range(&self) -> Range<i32> { self.y - self.height - 1 .. self.y } } impl Visible for Broom { fn draw(&self, canvas: &mut Canvas) { for y in self.broomstick_range() { ... } ... } ... }
-
9.2.1 - 默认方法
-
标准库的
Write特型的定义包含一个write_all的默认实现：trait Write { fn write(&mut self, buf: &[u8]) -> Result<usize>; fn flush(&mut self) -> Result<()>; fn write_all(&mut self, buf: &[u8]) -> Result<()> { let mut bytes_written = 0; while bytes_written < buf.len() { bytes_written += self.write(&buf[bytes_written..])?; } Ok(()) } ... }write和flush方法是每个书写器必须实现的基本方法；- 书写器也可以实现
write_all，如果没有，那就会使用上面的默认实现。
-
标准库中默认方法最多的是
Iterator特型，它有一个必须方法（.next()）和其他很多默认方法。
9.2.2 - 特型与其他人的类型
-
Rust 允许在任意类型上实现任意特型，只要当前包中导入了相关特性或类型即可。
-
每当想给任何类型添加方法时，都可以使用特型来完成：
trait IsEmoji { fn is_emoji(&self) -> bool; } /// 为内置字符类型实现IsEmoji方法，这种特型称为扩展特型 impl IsEmoji for char { fn is_emoji(&self) -> bool { ... } } assert_eq!('$'.is_emoji(), false); -
可以使用泛型
impl块，让一个类型家族一次性全部实现一个扩展特型。use std::io::{self, Write}; /// 为可以发送HTML的值定义扩展特型 trait WriteHtml { fn write_html(&mut self, html: &HtmlDocument) -> io::Result<()>; } /// 这样就可以向任意std::io::writer写入HTML了 // 对每个实现了Write的类型W，在这里为W再实现特型WriteHtml impl<W: Write> WriteHtml for W { fn write_html(&mut self, html: &HtmlDocument) -> io::Result<()> { ... } } -
serde为所有相关类型都添加了一个.serialize()方法：use serde::Serialize; use serde_json; pub fn save_configuration(config: &HashMap<String, String>) -> std::io::Result<()> { // 创建一个JSON序列化处理程序，将数据写入文件 let writer = File::create(config_filename())?; let mut serializer = serde_json::Serializer::new(writer); // 剩下的任务交给serde的.serialize()方法处理 config.serialize(&mut serializer)?; Ok(()) } -
连贯规则（coherence rule）：在实现特型时，相关的特型或类型必须都一个在当前包中是新的。确保特型实现的唯一性。
9.2.3 - 特型中的 Self
-
特型可以使用
Self关键字作为类型。pub trait Clone { fn clone(&self) -> Self; ... }Self作为返回类型：x.clone()的类型就是x的类型。
-
下述特型有两个实现：
pub trait Spliceable { fn splice(&self, other: &Self) -> Self } // self和other的类型必须完全一样 impl Spliceable for CherryTree { fn splice(&self, other: &Self) -> Self { // 此处Self是CherryTree的别名 ... } } impl Spliceable for Mammoth { fn splice(&self, other: &Self) -> Self { // 此处Self是Mammoth的别名 ... } } -
使用
Self类型的特型于特型目标不能共存：// 错误：特型Spliceable不能成为引用目标 fn splice_anything(left: &Spliceable, right: &Spliceable) { let combo = left.splice(right); ... }- 使用特型目标，类型在运行时才能确定；
- 在编译时，Rust 不能判断
left和right是不是同一种类型
-
特型目标只能针对最简单的特型实现。这种特型可以使用 Java 中的接口，或者 C++ 中的抽象基类实现。
-
特型的高级特型，不能与特型目标共存。
-
如何设计一个目标友好的特型：
pub trait MegaSpliceable { fn splice(&self, other: &MegaSpliceable) -> Box<MegaSpliceable>; } // 调用.splice()方法时，other参数的类型不必跟self的类型完全一样 // 只要两者的类型都是MegaSpliceable就可以通过类型检查
9.2.4 - 子特型
-
可以将一个特型声明为另一个特型的扩展
// 所有与角色Creature有关的代码，也可以使用来自Visible特型的方法 trait Creature: Visible { fn position(&self) -> (i32, i32); fn facing(&self) -> Direction; ... } -
所有实现
Creature的类型，必须也实现Visible特型：impl Visible for Broom { ... } impl Creature for Broom { ... } -
子类型类似 Java 或 C# 的字接口，是一个特型要用另外几个扩展已有特型的表达式。
9.2.5 - 静态方法
-
不同于其他面向对象语言，Rust 特型可以包含静态方法和构造函数。
trait StringSet { /// 返回一个新的空集合 fn new() -> Self; /// 返回一个包含strings中所有字符串的集合 fn from_slice(strings: &[&str]) -> Self; /// 确定当前集合是否包含特定的value fn contains(&self, string: &str) -> bool; /// 向当前集合中添加一个字符串 fn add(&mut self, string: &str); }-
所有实现
StringSet特型的类型，都必须实现这 4 个关联函数 -
前两个函数不接收
self参数，它们充当构造函数。在非泛型代码中，这些函数可以使用::语法调用，就跟调用其他静态方法一样：// 创建两个实现了StringSet的假设类型的集合 let set1 = SortedStringSet::new(); let set2 = HashedStringSet::new(); -
在泛型代码中，类型是可变的：
/// 返回document中不在wordlis中的词的集合 fn unknown_words<S: StringSet>(document: &Vec<String>, wordlist: &S) -> S { let mut unknowns = S::new(); for word in document { if !wordlist.contains(word) { unknowns.add(word); } } unknowns }
-
-
特型目标不支持静态方法：如果要使用特型目标
&StringSet，就必须修改特型，给每个静态方法都添加where Self: Sized绑定。trait StringSet { fn new() -> Self where Self: Sized; fn from_slice(strings: &[&str]) -> Self where Self: Sized; fn contains(&self, string: &str) -> bool; fn add(&mut self, string: &str); }- 告诉 Rust，特型目标将免于支持这个静态方法。
- 这样使用
&StringSet特型目标，可以调用.contains()和.add()方法。
9.3 - 完全限定方法调用
-
方法其实是一种特殊的函数：
"hello".to_string() // 等价于 str::to_string("hello") -
to_string是标准ToString特型的方法，上述代码等价于：ToString::to_string("hello") <str as ToString>::to_string("hello") -
上述 4 种方法调用，完成相同的操作：
- 一般情况下，
value.method()这种形式比较常用； - 其他形式称为限定方法调用：
- 需要指定方法关联的类型或特型
- 最后一种带尖括号的形式，同时指定了关联的类型，和特型，因此称为完全限定方法调用。
- 一般情况下，
-
完全限定方法调用，要确切指定使用的方法，应用场景有：
-
两个方法同名
outlaw.draw(); // 错误，.draw()方法中包含outlaw方法 Visible::draw(&outlaw); HasPistol::draw(&outlaw); -
无法推断
self参数的类型let zero = 0; // 类型未指定 zeor.abs(); // 错误，没有找到abs方法 i64::abs(zero); // 可以 -
将函数本身作为值
let words: Vec<String> = line.split_whitespace() // 产生&str值的迭代器 .map(<str as ToString>::to_string) // 可以 .collect(); -
在宏里调用特型方法。
-
-
完全限定语法也适用于静态方法。
9.4 - 定义类型关系的特型
- 特型是类型可以实现的一组方法。
- 特型可以用来描述类型之间的关系。有以下 3 种方式：
9.4.1 - 关联类型：迭代器的工作原理
-
std::iter::Iterator特型通过自身产生值的类型，将不同迭代器类型关联起来。 -
迭代器：能够通过它遍历一系列值的对象。
pub trait Iterator { type Item; // 关联类型（associated type） fn next(&mut self) -> Option<Self::Item>; ... }-
所有实现
Iterator的类型，都必须指定自己产生的项（item）的类型。 -
实现一个
Iterator的类型：// std::env标准库模块的部分代码 impl Iterator for Args { type Item = String; // 类型声明 fn next(&mut self) -> Option<String> { ... } ... }
-
-
泛型代码可以使用关联类型：
/// 遍历一个迭代器，将它们的值存储到一个新变量中 fn collect_into_vector<I: Iterator>(iter: I) -> Vec<I::Item> { let mut results = Vec::new(); for value in iter { results.push(value); } results } -
关联类型在特型需要覆盖除一个方法之外的定义时也很常用：
-
一个线程池的库中的
Task特型（表示工作单元），可以包含一个关联的Output特型； -
一个
Pattern特型（表示搜索字符串的一种方式），可以包含一个关联的Match类型，表示模式与字符串匹配之后收集到的所有信息：trait Patern { type Match; fn search(&self, string: &str) -> Option<Self::Match>; } /// 可以在字符串中搜索特定的字符 impl Pattern for char { /// Match（匹配）表示的时发现字符的位置 type Match = usize; fn search(&self, string: &str) -> Option<usize> { ... } } -
一个操作关系数据库的库可以有一个
DatabaseConnection特型，可以有表示事务、指针、初始化语句等的关联函数。
-
9.4.2 - 泛型特型：操作符重载的原理
-
std::ops::Mul特型关联可以参与乘法运算的类型。/// 支持*操作符的类型实现的特型 pub trait Mul<RHS> { // RHS：Right Hand Side右手边 /// 应用*操作符之后返回的类型结果 type Output; /// *操作符对应的方法 fn mul(self, rhs: RHS) -> Self::Output; }- 表达式
lhs * rhs是Mul::mul(lhs, rhs)的简写
- 表达式
9.4.3 - 伴型特型：rand::random 工作原理
rand中既包含一个跟随机数生成器有关的特型rand::Rng，还包含一个能够被随机生成的类型有关的特型rand::Rand。- 伴型特型：用来协同工作的特型。
9.5 - 逆向工程绑定
-
如下面的代码：
use std::ops::{Add, Mul}; fn dot<N>(v1: &[N], v2: &[N]) -> N where N: Add<Output=N> + Mul<Output=N> + Default + Copy // 对N的绑定 { let mut total = N::default(); for i in 0..v1.len() { total = total + v1[i] * v2[i]; } total } #[test] fn test_dot() { assert_eq!(dot(&[1, 2, 3, 4], &[1, 1, 1, 1]), 10); assert_eq!(dot(&[53.0, 7.0], &[1.0, 5.0]), 88.0); } -
对
N的绑定进行了逆向工程，让编译器当指导，反复检查自己的工作 -
Number特型包含所有操作符和方法。 -
逆向工程绑定的优点：
- 可以让泛型代码具有向前兼容的能力。
- 能通过编译器报错指导要解决的麻烦在哪里。
- 在代码和文档里都存在。
详见《Rust 程序设计》（吉姆 - 布兰迪、贾森 - 奥伦多夫著，李松峰译）第十一章
原文地址