Jared's Site

Rust Utility Traits

Sun, 23 Oct 2022 00:00:00 +0000

本文是对Programming Rust 第13章的总结，部分代码与图片来自此书

Utility Traits

rust中有很多常用的trait用来表达一些基础的语言特性，这些特性贯穿了整个rust语言的设计与应用，熟悉这些trait对于编写rust代码是必须的

`Drop`

drop发生在一个所有者终结的时候，他所持有的值就要一起被销毁，这些值包括堆内存，系统资源等等。drop通常发生在作用域结束，表达式结束或者Vec移除对象的时候。大部分时候rust会自动帮你销毁对象，这正是Borrow-Check机制的特别之处，在没有GC的情况下做自动内存管理

Drop被定义如下

1
2
3


trait Drop {
 fn drop(&mut self);
}

rust会在值销毁的时候自动调用drop，另外手工调用drop是不被允许的， rust编译器会报错

以下例子表明了drop发生的时机

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


 struct Appellation {
 name: String,
 nicknames: Vec<String>,
 }

 impl Drop for Appellation {
 fn drop(&mut self) {
 print!("Dropping {}", self.name);
 if !self.nicknames.is_empty() {
 print!(" (AKA {})", self.nicknames.join(", "));
 }
 println!("");
 }
 }

 {
 let mut a = Appellation {
 name: "Zeus".to_string(),
 nicknames: vec![
 "cloud collector".to_string(),
 "king of the gods".to_string(),
 ],
 };
 println!("before assignment");
 //a Owner another value, so the old value drop
 a = Appellation {
 name: "Hera".to_string(),
 nicknames: vec![],
 };
 println!("at end of block");
 //a drop the value it owns
 }

在这个例子中drop发生了两次，一次是重新赋值的时候，另外一次是作用域结束的时候

大多数情况，我们并不需要自己实现Drop，但是有些时候rust编译器识别不出值所拥有的资源类型的时候，你需要手工来释放资源,比如标准库中的文件句柄，通过drop来主动释放对于文件句柄的占用

1
2
3
4
5
6
7
8
9


struct FileDesc {
 fd: c_int,
}

impl Drop for FileDesc {
 fn drop(&mut self) {
 let _ = unsafe { libc::close(self.fd) };
 }
}

一个实现了Drop的类型，不能同时实现Copy,因为Copy代表了类型可以通过字节复制来完成拷贝，这种情况下可能会对于同样的数据drop多次，这种做法是错误的。

`Sized`

Sized代表了某种类型拥有固定大小， rust中大部分类型都是Sized, 数字，字符串，数组等。

Sized是一种Marker Trait，这表示它并不需要代码实现，而是由编译器自动实现

以下三种类型是Unszied Type

str
slice
trait object(dyn trait)

以下是三种类型的内存示意图

rust并不能直接把Unsized Type放在变量中使用，通常是通过放在引用或者智能指针后面使用比如&str, &[T],Box::<dyn Writer>.

除了以上三种类型之外， struct也允许在最后一个字段放置一个Unsized Type使它自己也变成Unszie Type,比如标准库中Rc的私有类型RcBox

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


struct RcBox<T: ?Sized> {
 ref_count: usize,
 value: T,
}

let boxed_lunch: RcBox<String> = RcBox {
 ref_count: 1,
 value: "lunch".to_string()
};
use std::fmt::Display;
let boxed_displayable: &RcBox<dyn Display> = &boxed_lunch;

对于一个Unsize Type你并不能直接构建，而是需要通过引用的方式间接实现

另外在泛型边界中，由于约束Sized是很普遍的情况，所以默认所有泛型<T>都会被自动转换成T:Sized, 如果你需要Unsized Type那么可以显示的指定为T:?Sized

`Clone`

Clone就是对一个值的深复制，标准库中的大部分类型都是适合复制的，也就是实现了Clone，但是某些特定的类型不合适，比如std::sync::Mutex是不允许复制的，因为锁是不能复制的，另外std::fs::File也是可以复制的，但是由于涉及到操作系统调用，并不能保证复制成功，所以它也没有实现Clone相反它提供了一个try_clone方法

`Copy`

Copy也是一种Marker Trait，它表明了一个类型可以进行字节浅复制，在所有Move发生的情况下，如果一个类型是Copy类型，那么Move不会发生，取而代之的是复制，也就是原来的值持有者保持可用

Copy只可以标记那些能够进行浅复制的类型，这个约束又编译器来保证，另外实现了Drop的类型不能同时实现Copy,两者不能同时存在于一个类型中

`Deref` and `DerefMut`

Deref是用来表达解引用，解引用与引用是一对相反的操作，对于引用类型来说可以用*T来表示，为了把这种操作推广到自定义类型，所以有了这一组Trait . 但是事实上能用到*的地方其实很少，考虑下面的类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


struct MyString {
 str: String,
 }

impl Deref for MyString {
 type Target = Stri
 fn deref(&self) -> &Self::Target {
 &self.str
 }

impl DerefMut for MyString {
 fn deref_mut(&mut self) -> &mut Self::Target {
 &mut self.str
 }
}

这是一个可以解引用为String的类型，也就是说Deref<MyString>->String

那么看一下我们可以怎么使用这个特性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 let mut my_string = MyString{str: "abc".to_string()};
 //无法通过编译， 因为不能Move &类型,
 let string = *my_string;
 let string = *(my_string.deref());
//通过强制接引用(deref coercion)实现，无需显示写出，也很难写，因为这里面不仅涉及到解引用，还涉及到借引用， 反正是神奇的dot operator的黑魔法
 _ = my_string.len();
//必须实现DerefMut才可以
 *my_string = "def".to_string();
 *(my_string.deref_mut()) = "def".to_string();
//跟下面的是一个意思
let mutstr = &mut "123".to_string();
*mutstr = "def".to_string();

从上面的例子可以看出，Deref只是参与了*操作，两者并不等价， *v操作可能等于*(v.deref())也可能等于v.deref().copy(), 具体怎么desugar还要看使用情况。我们需要在直觉方面保持一致

需要指出的是Box<T>是一个比较特别的类型，它可以通过*Box<T>将T给Move出来

1
2
3


let mut a = Box::new("abc".to_string());
//可以编译通过， 应该是编译器特性
let b = *a;

详细情况可以参考这个RFC

`AsRef`和`AsMut`

这两个trait允许从实现了T:AsRef的类型T中获取&U, 也是一种满足灵活性的设计，比如使用AsRef作为函数参数，就允许传入更多的类型需要说明的是，泛型并不会做强制类型转换，比如

1

impl AsRef<[u8]> for str {}

str类型实现了AsRef, 但是通常情况下，我们是使用&str来进行编码，这种情况编译器将在类型检查的时候无法通过，为了解决这个问题，标准库包含了一个通用实现

1
2
3
4
5
6
7
8


impl<'a, T, U> AsRef<U> for &'a T
 where T: AsRef<U>,
 T: ?Sized, U: ?Sized
{
 fn as_ref(&self) -> &U {
 (*self).as_ref()
 }
}

这使得，任何T: AsRef都同时有 &T:AsRef, 也就是通过T，&T都可以得到&U类型

`Borrow`和`BorrowMut`

Borrow与AsRef类似，也是获取T: AsBorrow,也是通过T获取&U的方式.所不同的是， AsBorrow通常约定T与U之间有某种联系,比如HashMap<K,V>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


use std::borrow::Borrow;
use std:#️⃣:Hash;

pub struct HashMap<K, V> {
 // fields omitted
}

impl<K, V> HashMap<K, V> {
 pub fn insert(&self, key: K, value: V) -> Option<V>
 where K: Hash + Eq
 {
 // ...
 }

 pub fn get<Q>(&self, k: &Q) -> Option<&V>
 where
 K: Borrow<Q>,
 Q: Hash + Eq + ?Sized
 {
 // ...
 }
}

HashMap<K, V>中存储的是K,V类型，但是它允许使用Q满足K: Borrow<Q>来查询K对应的值，这必然需要提供一下约束来保证实现，因为HashMap与hash, eq,ord等运算符有关系，比如要保证hash(K1)==hash(K2)的时候hash(Q1)==hash(Q2). 当你能满足K与Q的Eq,Ord, Hash都一致的时候就实现AsBorrow,否则就实现AsRef .另外Borrow也有一些通用实现，保证了K, &K, &mut K 作为K的时候， &K作为Q，也就是实现了K: AsBorrow<K>, &K: AsBorrow<K>, &mut K: AsBorrow<K>，当然还有更多的智能指针比如Box<K>: AsBorrow<K>

`From`和`Into`

这是一组一样用途的Trait，实现了From就会自动实现Into . T: From表示可以从U转换成T类型。From的一个典型用途就是?操作符，它可以将错误进行转换，符合函数需要的错误类型，从而简化代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


//所有实现了std::err::Error的类型都可以转换成Box<dyn Error>
impl<'a, E: Error + Send + Sync + 'a> From<E>
 for Box<dyn Error + Send + Sync + 'a> {
 fn from(err: E) -> Box<dyn Error + Send + Sync + 'a> {
 Box::new(err)
 }
}

type GenericError = Box<dyn std::error::Error + Send + Sync +
'static>;
type GenericResult<T> = Result<T, GenericError>;
fn parse_i32_bytes(b: &[u8]) -> GenericResult<i32> {
 Ok(std::str::from_utf8(b)?.parse::<i32>()?)
}

`ToOwned`

ToOwned的定义如下

1
2
3
4


trait ToOwned {
 type Owned: Borrow<Self>;
 fn to_owned(&self) -> Self::Owned;
}

它允许从&T中生成一个U: Borrow<T>, 这使得它的使用范围比Clone要大，你可以从多种可能的类型中选择一种， Clone只能返回T类型，比如[T]可以实现成ToOwned<Owned=Vec<T>>, 因为Vec<T>:Borrow<[T]>，相反[T]因为是Unsized Type, 是不允许实现Clone的

`Cow`

Cow是Copy On Write的意思，它的定义是一个Enum类型

1
2
3
4
5
6


enum Cow<'a, B: ?Sized>
 where B: ToOwned
{
 Borrowed(&'a B),
 Owned(<B as ToOwned>::Owned),
}

可以看出来，它利用了Borrow和ToOwned两种Trait来实现，一个Cow即可以是一个&B，也是可以是T: Borrow, 其中T是值， &B是引用，当必要的时候这两个之前可以互相转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


use std::path::PathBuf;
use std::borrow::Cow;
fn describe(error: &Error) -> Cow<'static, str> {
 match *error {
 Error::OutOfMemory => "out of memory".into(),
 Error::StackOverflow => "stack overflow".into(),
 Error::MachineOnFire => "machine on fire".into(),
 Error::Unfathomable => "machine bewildered".into(),
 Error::FileNotFound(ref path) => {
 format!("file not found: {}", path.display()).into()
 }
 }
}

Rust Iterators

Thu, 20 Oct 2022 00:00:00 +0000

本文是对Programming Rust 第15章的总结，部分代码与图片来自此书

一个简单的例子

1
2
3
4
5
6
7
8
9


//normal style
let mut sum = 0;
for i in 0..=10 {
 sum += i;
}
println!("{}", sum);
//iterator style
let sum = (0..=10).fold(0, |sum, i| sum+i);
println!("{}", sum);

以上两种求和的实现是等价，基于iterator的实现风格对于函数式编程是很常见的， rust也提倡这种方式的写法，不同的是，rust编译器在编译的时候会对这种表达方式进行优化，达到一种zero cost abstraction的效果，比如以上的求和在编译器优化后可能汇编代码使用11*10/2这种数学公式来执行。这个意思是不用太担心iterator风格的性能问题， rust编译器会进行必要的优化，使得我们使用的时候表达能力与性能兼顾

`IntoInterator`和`Iterator`

在rust中iterator最基本的两个trait是IntoInterator和Iterator，他们的定义如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


trait Iterator {
 type Item;
 fn next(&mut self) -> Option<Self::Item>;
 ... // many default methods
}

trait IntoIterator where Self::IntoIter:Iterator<Item=Self::Item> {
 type Item;
 type IntoIter: Iterator;
 fn into_iter(self) -> Self::IntoIter;
}

IntoIterator用来生成Iterator, 实现Iterator可以进行相应的操作， Iteratortrait包含了很多函数，但是需要实现的只有一个next.

值得一提的是IntoIterator的into_iter使用传值的方式，也就表明了这个方法会将原始类型给消费掉，进行Copy或者Move, 比如

1
2
3
4


let v = vec![1,2,3];
 //into_iter() move the vecotr v
let iter = v.into_iter();
println!("{}", v[0]);

以上的代码不能编译通过，因为v已经被Move了，你可以使用引用来避免这个问题

1
2
3
4
5


let v = vec![1,2,3];
 //以下两种方式等价
let iter = (&v).into_iter();
let iter2 = v.iter();
println!("{}", v[0]);

由于这个使用方式很常见，所以Vec直接提供了方法Vec<T>::iter()，他会返回一个生成&T类型的Iterator

rust中的for loop其实是使用Iterator来实现的，以下的代码是等价的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


 let v = vec![1,2,3,4];
 for i in &v {
 println!("{}", i);
 }

 //translate to this by compiler
 let mut iter = v.iter();
 while let Some(i) = iter.next() {
 println!("{}", i);
 }

很多时候可以使用IntoIterator作为泛型的边界来使用，比如

1
2
3
4
5
6
7
8
9


use std::fmt::Debug;
fn dump<T, U>(t: T)
 where T: IntoIterator<Item=U>,
 U: Debug
{
 for u in t {
 println!("{:?}", u);
 }
}

在这个例子里面，表示T必须是一种可以产生Iterator，这个Iterator产出的类型U必须是实现了Debug的

`drain`方法

很多collection提供了drain方法，它通过collection的可变引用返回一个Iterator, 当这个Iteratro drop之后，这些被包含的元素就从colleciton当中移除了

1
2
3
4
5


 let mut v = vec![1,2,3,4];
 {
 let drain_iter = v.drain(2..4);
 }
 assert_eq!(&v, &vec![1,2]);

标准库应用

Iterator在标准库中有广泛的应用，不止在collection中，还在很多其他方面，比如io当中，使用Iterator来处理io流，尤其在异步io中。

另外对Iterator风格代码的使用，对于非函数式编程习惯的人员来说有一定的门槛，需要多练习才能适应，下面将重点介绍以下Iterator适配器

`Iterator`适配器

rust的Iterator适配器非常灵活，下面将逐个介绍

`map` and `filter`

这两个应该很好理解

统一处理Vec中的元素

1
2
3
4
5
6


let text = " ponies \n giraffes\niguanas
 \nsquid".to_string();
let v: Vec<&str> = text.lines()
 .map(str::trim) ////map的FnMut类型为FnMut(I::Item) -> B, Item由上一个Iterator决定， B由这个FnMut决定
 .collect();
assert_eq!(v, ["ponies", "giraffes", "iguanas", "squid"]);

过滤Vec中的元素

1
2
3
4
5
6
7


let text = " ponies \n giraffes\niguanas
\nsquid".to_string();
let v: Vec<&str> = text.lines()
 .map(str::trim)
 .filter(|s| *s != "iguanas") //FnMut(&Self::Item) -> bool， Item由上一个Iterator决定
 .collect();
assert_eq!(v, ["ponies", "giraffes", "squid"]);

需要注意的是

rust中adaptor是lazy的，也就是说不管chain了多少个adaptor，这些操作只有被消费的时候才执行，具体就是只有adaptor调用了collect的时候，操作才被真正执行
adaptor是zero cost abstraction，这意味着rust编译器会将这些chain内联到最后消费的地方，比如执行的时候就像是一个for循环语句一样，这样做可以明显的提高执行效率

`filter_map` and `flat_map`

filter_map有点像map和filter的组合体，它要么转换一个值，要么丢弃一个值，使用filter_map有时候比使用组合方式更加方便和优雅，比如只有在你转换一个值的时候才能决定是否要丢弃一个值

1
2
3
4
5
6
7
8



let text = "1\nfrond .25 289\n3.1415 estuary\n";
for number in text
 .split_whitespace()
 .filter_map(|w| f64::from_str(w).ok())
{
 println!("{:4.2}", number.sqrt());
}

在上个例子中，你只有做数字转换的时候才知道要不要保留这个值

flat_map就是在每个FnMut中制造出一个Iterator, 然后再把这些Iterator合并起来，当然这些都是语义层面的，真正执行的时候，编译器会做相应的优化, 可能并不会真的做Iterator合并

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 let mut major_cities = HashMap::new();
major_cities.insert("Japan", vec!["Tokyo", "Kyoto"]);
major_cities.insert("The United States", vec!["Portland",
"Nashville"]);
major_cities.insert("Brazil", vec!["São Paulo", "Brasília"]);
major_cities.insert("Kenya", vec!["Nairobi", "Mombasa"]);
major_cities.insert("The Netherlands", vec!["Amsterdam",
"Utrecht"]);
let countries = ["Japan", "Brazil", "Kenya"];
for &city in countries.iter().flat_map(|country|
&major_cities[country]) {
 println!("{}", city);
}

`flatten`

flatten就是值将Iterator中的每个元素也当成Iterator，然后取第二级中的元素作为输出， flatten通常是值将2层级变为1层级的操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


let mut parks = BTreeMap::new();
parks.insert("Portland", vec!["Mt. Tabor Park", "Forest Park"]);
parks.insert("Kyoto", vec!["Tadasu-no-Mori Forest", "Maruyama
Koen"]);
parks.insert("Nashville", vec!["Percy Warner Park", "Dragon
Park"]);
// Build a vector of all parks. `values` gives us an iterator producing
// vectors, and then `flatten` produces each vector's elements in turn.
let all_parks: Vec<_> =
parks.values().flatten().cloned().collect();
assert_eq!(all_parks,
 vec!["Tadasu-no-Mori Forest", "Maruyama Koen", "Percy
Warner Park",
 "Dragon Park", "Mt. Tabor Park", "Forest Park"])

上面的示例将Vec元素打平成&str作为结果， 3个Vec变成了6个&str

flatten与Option配合使用将会有很妙的效果

1
2
3
4
5


assert_eq!(vec![None, Some("day"), None, Some("one")]
 .into_iter()
 .flatten()
 .collect::<Vec<_>>(),
 vec!["day", "one"]);

上面的示例将Vec<Option>变成了Vec<&str>，这是因为Option本生也实现了IntoIterator 返回了非None的值，同样的方式也适用于Result

有的时候flatten与map的组合其实就等于flat_map，这种情况下使用flat_map会显得更方便与直接

`其他`

其他还有很多常用的适配器，比如take, skip， peekable, fuse, chain 等等，暂且不做讨论

Rust Struct

Sun, 16 Oct 2022 00:00:00 +0000

本文是对Programming Rust 第9章的总结，部分代码与图片来自此书

Struct

基本用法

在rust中， struct分为三种类型，分别为named, tuple-like, unit-like

1
2
3
4
5
6
7
8
9


struct User {
 id: usize,
 name: String,
 manager: Option<Rc<User>>,
}

struct Point(usize, usize);

struct empty;

关联方法可以使用self, &self, &mut self, Box<Self>, Rc<Self>等self参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


impl User {
 fn new(id: usize, name: String) -> Self {
 User { id: id, name: name, manager: None }
 }

 fn get_name(&self) -> String {
 self.name.clone()
 }

 fn set_name(&mut self, name: String) {
 self.name = name;
 }

 fn move_user(self) -> User {
 self
 }

 fn manage(self: Rc<Self>, user: &mut User) {
 user.manager = Some(self);
 }
}

可以这样调用这些方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


fn main() {
 let mut member = User::new(1, "jared".to_string());
 let manager = User::new(2, "jerry".to_string());
 //&mut self
 member.set_name("abc".to_string());
 //&self
 member.get_name();
 //Rc<Self>
 Rc::new(manager).manage( &mut member);
 //Box<Self>
 let m2 = Box::new(member);
 m2.get_name();
}

调用函数时，类型会自动转换(implicit conversion), 当然是在满足规则的情况下，一个&self是没办法自动转换成一个&mut self，相反则是成立的

内部可变性

有的时候，你需要在程序中共享一些struct，比如说配置参数，由于使用Rc，这个时候这个配置结构是不可变的。但是很多时候，你还是希望可以修改它的某些属性，这个时候就要用到内部可变性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


//配置参数
struct Config {
 path: RefCell<String>,
 timeout: 5,
}

//实例
struct Instance {
 conf: Rc<RefCell<Config>>
}

//共享配置参数
 let config = Rc::new(Config{path: RefCell::new("/abc".to_string()),timeout: 5});
 let mut ins = Instance{conf: config.clone()};
 let ins2 = Instance{conf: config};

//Config本身是immutable的， 但是可以通过内部可变性，改变path的值
 let _ = ins.conf.path.borrow_mut().replace("abc", "xyz") ;
 println!("{}", ins2.conf.path.borrow());

内部可变性的问题在于，它打破了rust编译期的借用规则，但是在运行期，如果它同时存在一个可变引用与不可变引用，程序会panic, 也就是说在运行期它依然要遵循借用规则

Rust Shared And Mutable References

Sat, 15 Oct 2022 00:00:00 +0000

本文是对Programming Rust 第5章的总结，部分代码与图片来自此书

共享引用与可变引用

虽然可以同时存在多个共享引用，但是当共享引用存在的时候，不但不能够存在可变引用，甚至你也不能修改或者move 拥有者本身，比如

1
2
3
4


let v = vec![4, 8, 19, 27, 34, 10];
let r = &v;
let aside = v; // move vector to aside
r[0]; // bad: uses `v`, which is now uninitialized

上面的v 在被引用的时候move给了r，这种操作是编译器禁止的

一个场景是在编程当中经常出现的，比如你需要复制字符串自身,使用rust，你可能会这样实现

1
2
3
4
5
6
7
8


fn extend(vec: &mut Vec<f64>, slice: &[f64]) {
 for elt in slice {
 vec.push(*elt);
 }
}

let wave = vec![0.0, 1.0];
extend(&mut wave, &wave);

但是这种操作是被编译器禁止的，由于修改wave的时候很可能改变它的内存地址，比如扩充大小，这个时候slice指向了已经被摧毁的内存地址，程序就会出现访问无效内存的问题，以下是示意图

这些编译错误使我们重新看一下rust的引用规则

共享访问

被共享引用的值是只读的，在共享引用的周期内，这个值不能被改变，即使是通过变量本身也不行
排他访问

可变引用是排他的，在可变引用周期内，这个值甚至不能被访问，唯一的例外就是可以reborrow这个可变引用

一下是一些体现这些规则的例子

共享引用期间不能修改

1
2
3
4


 let mut y = 10;
 let r = &y;
 y = 11; //can not change y
 println!("{}", r);

可变引用期间不能问

1
2
3
4
5
6


 //can not use of mut borrowed y, even it is copy type
 let mut y = 10;
 let r = &mut y;

 let z = y; //can not access y
 print!("{}, {}", r, z);

从共享引用`reborrow`

1
2
3
4
5


 let mut w = (107, 109);
 let r = &w;
 let r0 = &w.0;

 println!("{:?}, {}", r, r0);

从可变引用`reborrow`

1
2
3
4
5
6
7
8
9



 let mut w = (100, 101);
 let m = &mut w;
 let m0 = &mut m.0; //reborrow mutable from m
 // let m0 = &mut w.0; //not possible, can only reborrow from m
 let r1 = &m.1; //reborrow shared from m

 // let v = w.0; //can not accessed, because of mut borrowed by m
 print!("{:?}, {}",r1, m0);

这些限制可能看起来很奇怪，也会限制灵活性。但是能排除一些安全隐患，最典型的就是同时操作自身的例子，比如操作一个文件，我们很可能会复制自身

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


struct File {
 descriptor: i32
}
fn new_file(d: i32) -> File {
 File { descriptor: d }
}
fn clone_from(this: &mut File, rhs: &File) {
 close(this.descriptor);
 this.descriptor = dup(rhs.descriptor);
}


let mut f = new_file(open("foo.txt", ...));
...
clone_from(&mut f, &f);

如果以上代码能够执行，那么显然跟我们预期不太一样，一个我们希望复制的文件已经被关闭了

这些现在也会在并发编程的时候带来一些好处，因为并发中的竞争就是因为多个线程对于同个变量的修改导致的。但是rust中并不允许同时存在多个可变引用。

对象海

垃圾回收机制的引入通常导致了对象海的产生，开发者会在代码中将各个对象互相引用，这样做可能会提高一点开发效率，但是由于缺乏良好的设计，随着代码量的增加，系统很快就会变成一团乱麻，难以维护， rust严格的所有权机制会使开发者提前思考系统设计，写出更好，更加可维护的程序

Rust References

Mon, 11 Apr 2022 00:00:00 +0000

本文是对Programming Rust 第5章的总结，部分代码与图片来自此书

引用类型

rust有三种指针类型

引用
裸指针
智能指针

其中引用是一种非拥有指针，即不需要对被引用对象的生命周期负责，相反，引用的生命周期不能超过被引用者的生命周期

很多时候我们并不想转移值的所有权，仅仅需要访问值的某些数据，这个时候就需要使用引用了。

引用分为两种类型：

共享引用 可以读取被引用对象但是不能修改。同时可以存在多个共享引用，共享引用本身是Copy类型
可变引用可以读取并且修改被引用对象，同时只能存在一个可变引用，并且可变引用存在的时候，不能存在任何共享引用，可变引用不是Copy类型

需要说明的是， 可变引用存在的时候，不但是共享引用不能存在， Owner自己也不能访问和修改被引用对象

使用引用

以下是使用引用的一些示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


//共享引用
let x = 10;
let r = &x;
assert!(*r == 10);

//可变引用
let mut y = 32;
let m = &mut y;
*m += 32;
assert!(*m == 64);

隐式解引用/隐式借引用

这里需要注意的是由于解引用，借引用是非常常见的操作，而且编码起来显得非常繁琐，所以rust对.操作符的左值做了隐式解引用与隐式借引用的操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//隐式解引用， 接引用
struct Anime {
 name: String,
 bechdel_pass: bool,
};
let aria = Anime {
 name: String::from("Aria: The Animation"),
 bechdel_pass: true,
};

//隐式借引用
aria.print();
(&aria).print();

let anime_ref = &aria;
//隐式解引用
println!("Hello, {}!", anime_ref.first_name);
println!("Hello, {}!", (*anime_ref).first_name);

嵌套引用

rust中引用本身也是一个左值，所以可以对引用再引用，比如

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


struct Point {
 x: i32,
 y: i32,
}
let point = Point { x: 1000, y: 729 };
let r: &Point = &point;
let rr: &&Point = &r;
let rrr: &&&Point = &rr;

//*操作符 循环解引用
let rr0:&&Point = *rrr;
let r0: &Point = *rrr;
//.操作符循环解引用，直到到对应的值
let y: 32 = rrr.y;

有个值得注意的点是在The book中有一段是这么说的

Note that the * operator is replaced with a call to the deref method and then a call to the * operator just once, each time we use a * in our code

上面的代码表面，对于引用，一个*操作符可以直接解引用到多个层级之上的类型。

我认为这是由于当我指定了类型之后， rust编译器会根据目标类型进行Deref Coercion, 我姑且叫它强制类型转换，强制类型转换会无限的将一个引用转成它可以转换到的引用，如果一个类型符合 T: Deref<Target=U>

引用比较/计算

引用比较的是他们背后的值，引用只能在相同类型直接做比较

引用运算可以计算一层引用的背后的值，多层引用则不能相加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


let x = 10;
let y = 10;
let rx = &x;
let ry = &y;
let rrx = &rx;
let rry = &ry;
assert!(rrx <= rry);
assert!(rrx == rr
assert!(rx == ry); // their referents are equal
assert!(!std::ptr::eq(rx, ry)); // but occupy different addresses

//引用相加
let n = rx + ry;
assert_eq!(n, 20);
let m = rrx + rry; //编译不通过， 这两个变量不能相加

胖指针

rust有两种常见的胖指针

对slice的引用, 额外包含length信息
对trait object的引用，额外包含trait实现地址，即虚表

胖指针名字的来源是因为这种指针包含两个字长，一般的指针只包含一个。

指向unszie type的指针都是胖指针

引用安全

引用在rust中是内存安全的，引用不会产生悬空指针的问题，rust通过lifetime来解决这个问题，以下这个段代码展示了违背生命周期的情况

1
2
3
4
5
6
7
8


{
 let r;
 {
 let x = 1;
 r = &x;
 }
 assert_eq!(*r, 1); // bad: reads memory `x` used to occupy
}

x在引用r之前被释放了，这种情况是无法通过编译的, rust对于生命周期的限制如下：

假如我们有一个变量v的引用&v，使变量r=&v，我们必须满足

变量v的生命周期必须包含&v的生命周期
&v的生命周期必须包含r的生命周期

这两种情况任意一个不满足都会产生悬空指针。

在我看来r是v的一个引用，只需要满足v的生命周期包含r的生命周期即可

引用作为函数入参

一个带lifetime的函数是这样子的

1

fn f<'a>(p: &'a i32){}

这里f<'a> ‘a是作为函数的参数存在，我们可以认为是对于任意生命周期都适用，大部分情况下，一个实参的周期是大于函数调用的。但是如果函数中存在这种情况，就不行了

1
2
3
4
5
6


static mut STASH: &i32 = &128;
fn f(p: &i32) {
 unsafe{
 STASH = P;
 }
}

STASH的生命周期是全局的，而根据上面的规则2，p的生命周期必须包含’static。显然对于任意生命周来说这是不满足的。这个时候只有将形参改成’static才能满足这个条件

1
2
3
4
5


fn f(p :&'static i32){
 unsafe{
 STASH = P;
 }
}

以上的函数是正确的，但是适用范围也更小了。

引用作为函数返回

以下是一个返回引用的函数

1
2
3
4
5
6
7
8
9


fn smallest(v: &[i32]) -> &i32 {
 let mut s = &v[0];
 for r in &v[1..] {
 if *r < *s {
 s = r;
 }
 }
 s
}

我们忽略了生命周期，当一个函数只有一个引用作为参数的时候，如果它的返回值包含引用， rust会认为它们有同样的生命周期。现在考虑以下的代码

1
2
3
4
5
6
7



let s;
{
 let parabola = [9, 4, 1, 0, 1, 4, 9];
 s = smallest(&parabola);
}
assert_eq!(*s, 0);

根据上面的规则1，2，必须满足parabola的生命周期必须大于s的生命周期，这段代码中parabola要比s更早drop，所以是不能通过编译的

结构体包含引用

结构体必须包含生命周期参数，不然是无法通过编译的

1
2
3
4
5
6
7
8


//含引用结构体
struct S<'a> {
 r: &'a i32
}
//嵌套含引用结构体
struct D<'a> {
 s: S<'a>
}

省略`生命周期`参数

省略生命周期有以下几种情况：

函数不返回引用的情况下，不需要显示指定生命周期
如果函数只有一个参数，那么也不需要指定生命周期，因为rust为认为任何返回引用的生命周期都与此参数相同
如果函数是一个类型的方法，并且形参是引用类型self(&self, &mut self)， rust会认为返回引用的生命周期与此相同

后续

rust的引用是一个根本又复杂的话题，这里还有很多东西没有讨论清楚，比如强制类型转换，比如重借用等等，后续还需要进一步的研究

Rust Ownership And Move

Sun, 10 Apr 2022 00:00:00 +0000

本文是对Programming Rust 第4章的总结，部分代码与图片来自此书

背景

我们通常希望变成语言提供以下特性：

我们希望可以控制内存释放的时机
我们不希望使用一个对象已经被释放的指针

c/c++与带gc的语言通过不同的机制解决以上问题，但是都各自有不同的缺点 rust使用了Ownership与Borrow来解决内存管理的问题

`Ownership`

在rust中一个变量被赋值的时候就拥有了这个值的所有权，一个Struct拥有字段的所有权，一个Tuple，Array，Vec拥有包含元素的所有权。
一个值只能被一个变量拥有，这个变量会对此值的生命周期负责，当一个变量被Drop的时候它所拥有的所有值也会一起被销毁

以下代码创建了一个Vec，它包含了多个结构体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40



 struct Person {

 name: String,

 birth: i32,

 }

 let mut composers = Vec::new();

 composers.push(Person {

 name: "Palestrina".to_string(),

 birth: 1525,

 });

 composers.push(Person {

 name: "Dowland".to_string(),

 birth: 1563,

 });

 composers.push(Person {

 name: "Lully".to_string(),

 birth: 1632,

 });

 for composer in &composers {

 println!("{}, born {}", composer.name, composer.birth);

 }

它的内存布局为

在很多情况下，这种一对一的绑定关系显然缺乏灵活性，在真实的编程当中，对象之间的互相引用，多个对象引用同一个对象是很常见的(比如双向链表，树结构等等)。所以rust在所有权原则的基础上提供很多其他机制来达成这种灵活性

`Move`

在rust中，像赋值，对函数传值，函数返回值等操作会使一个变量转移它对值得所有权，在一个变量转移所有权之后，它会变成未初始化状态，后续得代码无法访问该变量。比如以下代码

1
2
3
4
5
6



 let s = vec!["udon".to_string(), "ramen".to_string(), "soba".to_string()];

 let t = s;

 let u = s;

在内存中的布局如下所示

s在把值转移给t后变为未初始化状态，同时t只是对s的值本身(Value Proper)做了赋值。这里的Value Proper我理解的意思就是，大部分情况就是一个值的栈上数据，因为栈上数据不需要做内存管理；当然肯定存在堆上数据做Move的情况，总的来说编译器会做一次浅复制
Move操作保证了一个值始终只有一个拥有者，所以有且只有一个人会对这个值的内存管理负责

控制流中的`Move`

rust编译器会根据条件语句来判断，一个值是否被Move，比如

if/else语句

1
2
3
4
5
6
7


let x = String::from("hello, move");
if c {
 f(x); //这个move允许
}else {
 g(x); //这个move也允许
}
h(x); //这里无论哪种情况move都已经发生

循环语句

1
2
3
4


let x = String::from("hello, move");
while c {
 g(x); //这里编译不会通过，因为x会再第一次move的时候失效
}

数组中的`Move`

一个Vec V中的元素属于V, 不能将他Move给其他变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14



 // Build a vector of the strings "101", "102", ... "105"

 let mut v = Vec::new();

 for i in 101..106 {

 v.push(i.to_string());

 }

 // Pull out random elements from the vector.

 let third = v[2]; // error: Cannot move out of index of Vec let fifth = v[4]; // here too

当然了一个Vec必须可以删除元素，比如移除队尾数据，移除数据并且使用队尾填充，还有著名的mem::replace, 这些方法都遵循一个原则就是保证vec在一个连贯的状态,使得Vec只在记录length的情况下就能维护本身的状态。由于对外赋值会导致Move，所以一般赋值操作可以使用Borrow或者Clone

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// Build a vector of the strings "101", "102", ... "105"

 let mut v = Vec::new();

 for i in 101..106 {

 v.push(i.to_string());

 }

 // 1. Pop a value off the end of the vector:

 let fifth = v.pop().expect("vector empty!");

 assert_eq!(fifth, "105");

 // 2. Move a value out of a given index in the vector,

 // and move the last element into its spot:

 let second = v.swap_remove(1);

 assert_eq!(second, "102");

 // 3. Swap in another value for the one we're taking out:

 let third = std::mem::replace(&mut v[2], "substitute".to_string());

 assert_eq!(third, "103");

 // Let's see what's left of our vector.

 assert_eq!(v, vec!["101", "104", "substitute"]);

值得一提的是，一个Vec使用remove方法删除index处的元素时，所有右边的元素都会左移，这个操作消耗是很大的。不过这个东西跟rust无关，所有语言都是这么实现
另外在一个for循环中，我们会将整个Vec转移出去，并且将他打散成各个元素，后续不管这些元素有没有被再次转移，整个初始Vec已经不可见了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


let v = vec!["a".to_string(), "b".to_string(), "c".to_string()];



 for mut s in v { //move the entire v

 if s == "b".to_string() {

 break;

 }

 }



 println!("{}", v[2]) //v is moved, 编译不通过

Copy

在rust中对于简单类型，也使用Move语义是没有必要的, 因为简单类型除了自己的值本身之外并没有要额外管理的资源，这个资源可能是堆内存，可能是文件句柄等。这个时候对一个变量赋值应该是直接Copy就可以了，事实上他跟Move就仅仅是是否清除原变量的值本身，原变量是否保持可用

Copy类型包含了

整数，浮点，字符，布尔，指针等
Copy类型组成的Tuple
Copy类型组成的Array
指定了Copy的Struct
指定了Copy的枚举
所有复制只需要位拷贝的类型

不包含

所有Drop的时候需要额外处理的都不是Copy类型
默认的`Struct
默认的Enum

`Rc`和`Arc`

有了Move跟Copy之后，值的使用仍然比较受限，很多时候我们希望可以有多个变量持有同一个值，就像其他语言一样。这个时候Rc就派上用场了，一个Rc就是在遵循前面几种规则的基础上，创造出的一种引用计数类型。

按照Ownership的原则，是不允许多个变量同时持有一个值T的。那么怎么做呢？答案就是把值T包装到一个容器里，容器本身遵循Ownership, 容器内部来决定何时drop关联的值T, 这里这个容器就是Rc.
Rc的共享使用Clone来实现, Clone操作只是对引用计数+1，当变量被Drop时引用技术-1，当引用技术变为0的时候， Rc所包装的值T被释放
Rc所包装的值T是不可变的，这个符合单个可变与多个共享之间的排斥性,某些情况下可以使用内部可变性容器来解决这个问题，比如Cell

1
2
3
4
5
6



 let s: Rc<String> = Rc::new("shirataki".to_string());

 let t: Rc<String> = s.clone();

 let u: Rc<String> = s.clone();

以下是Rc的内存布局

Rust String Type

Fri, 08 Apr 2022 00:00:00 +0000

string和&str

rust中操作字符串比较常用的是String和&str 比如：

1
2
3
4
5
6


let string = String::from("hello, world");

//以下三种都为&str类型
let s = "hello, world"; //字面常量 string literal， 存储在常量区
let hello = &string[..5]; //从string中得到&str
let world = &s[6..]; //从&str中得到&str

内存布局

以下是String与&str在内存中的结构，String占用了3个字长，&str占用两个字长。他们都有一个指向底层数组的指针。

实现源码

string的内部实现就是一个Vec[u8]

1
2
3
4
5


pub struct String {

 vec: Vec<u8>,

}

vec本身的实现如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> {

 buf: RawVec<T, A>,

 len: usize,

}

pub(crate) struct RawVec<T, A: Allocator = Global> {

 ptr: Unique<T>,

 cap: usize,

 alloc: A,

}

以上可以看出string的内存占用从何而来

str是一个原生类型，字面常量的完整类型是&‘static str, 虽然没有str的类型定义，但是从它的方法中也可以找到它的内部结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20



let story = "Once upon a time...";

let ptr = story.as_ptr();
let len = story.len();

// story has nineteen bytes
assert_eq!(19, len);

// We can re-build a str out of ptr and len. This is all unsafe because
// we are responsible for making sure the two components are valid:
let s = unsafe {
 // First, we build a &[u8]...
 let slice = slice::from_raw_parts(ptr, len);

 // ... and then convert that slice into a string slice
 str::from_utf8(slice)
};

assert_eq!(s, Ok(story));

str的其他使用方式

理论上可以通过各种方式得到str类型本身，然而编译器并不能通过，主要是因为str类型为unsize type，并不能够在栈中存在。比如

1
2
3
4
5
6
7
8
9


let string = String::from("hello, world");


let s = "hello, world";

//以下三个变量都为str类型
let ss = *s;
let h = string[..5];
let w = s[6..];

`Box<str>`

既然str不能在栈上存在，那么能不能显式放到堆上呢？答案是可以的,那就是Box<str>，但是Box<str>只能通过以下一种方式初始化

1
2
3
4


let string = String::from("hello, world");

//除了&str,你还可以使用Box<str>,下面是可以创建Box<str>的唯一方法
let box_s = string.into_boxed_str();

Box<str>同样是占用2个字长，事实上，当一个unsize type被放在引用或者指针后面的时候它就是一个2字长胖指针，比如&[u8], &dyn Trait都是如此， *const [T]也是一样

`Cow<str>`

很多时候，我们希望函数接口保持兼容性与灵活性，通常使用&str而不是String或者·&String作为接口，但是作为返回，如果这个函数并没有修改这个&str,那么我们希望可以直接返回它，但是当这个函数改变了值，我们只能复制这个str并且返回String类型以获得owned值。这个时候Cow<str>就派上了用场。以下是定义

1
2
3
4
5
6
7


pub enum Cow<'a, B>
where
 B: 'a + ToOwned + ?Sized,
 {
 Borrowed(&'a B),
 Owned(<B as ToOwned>::Owned),
}

标准库中，对于Cow<str>的使用有from_utf8_lossy返回&str

不需要分配新的内存

1
2
3
4
5
6


// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);

assert_eq!("💖", sparkle_heart);

返回String, 由于修改了字符串内容，重新复制了内存

1
2
3
4
5
6



// some invalid bytes
let input = b"Hello \xF0\x90\x80World";
let output = String::from_utf8_lossy(input);

assert_eq!("Hello �World", output);

在crate regex中有一个replace方法，同样使用Cow<str>作为返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 pub fn replace_all<'t, R: Replacer>(

 &self,

 text: &'t str,

 rep: R,

 ) -> Cow<'t, str> {

 self.replacen(text, 0, rep)

 }

我们可以直接使用Cow<str>，打印或者写入文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


//new 一个正则表达式
let regex = Regex::new(target).unwrap();
//返回一个Cow<str>
let cow = regex.replace_all(text, replacement);
//打印字符串
println("str is {}", cow);

//输出到文件, 这个需要注意&*cow得到&str类型
// &(*cow.deref())
fs::write("output.txt", &*cow)

MapReduce

Sat, 25 Sep 2021 00:00:00 +0000

系统描述

根据Google论文mapreduce开发一个简易的mapreduce系统，可以处理多个数据文件，最后生成一个结果，课程案例主要是对文本进行WordCount，首先通过map统计每个word出现的次数，然后通过reduce计算count

设计

Coordinator 协调者负责分配任务，包括map任务，reduce任务。
Worker 执行map， reduce任务，任务通过rpc请求Cooridnator获取
Coordinator要包含错误处理，错误包括任务失败与任务缓慢，处理措施都是重试

实现

Coordinator包含两个任务队列,一个mapTasks，由输入文件数决定；一个reduceTasks,由reduce数量决定
当worker请求任务时， Coordinator会分配一个Ready状态的任务，任务一旦分配就设置成Pending状态。
Worker完成任务后，通知Coorinator，此Task已完成, 等待1秒后继续请求下一个任务
当所有reduceTask都完成后，整个任务完成

错误处理

当一个任务pending超过10秒后，如果状态不为Finish，则重新设置成Ready
Worker执行任务失败后，直接结束当前循环，等待下一个任务请求
任务执行成功后， Coordinator会对请求任务的worker返回Done标记， worker接收标记后退出；如果Coordinator已经退出，则网络连接失败， Worker退出；其他情况Worker会一直循环请求任务
Map Worker将TempFile作为中间数据，并将这些文件传输给Master，以供Reduce Worker使用。一个已经成功返回的MapTask将忽略其他的返回
Reduce Worker会使用TempFile作为中间输出，当前任务完成后，Rename这些文件到正确的文件目录，所以当Worker执行失败时这些文件并不可见

流程图

任务流

Wed, 08 Sep 2021 21:33:24 +0800

需求描述

由于前端展示的多样性，需要一个可以灵活配置的Api Gateway, 这个gateway不能仅仅满足http请求都后端微服务的转发，还必须可以定义微服务返回结果之间的组合，组合的灵活性当然是不可能达到代码的程度，但是应该可以满足常见的数据拼接，比如结果集的简单Merge，比如数据集详情扩展，比如B接口请求依赖A接口的返回值等。
要能够请求多个接口，并且这些请求之间有一定的依赖关系， DAG是一个自然的选择，如果把每个请求当成单个节点上的任务, 那么任务之间的依赖关系可以通过节点依赖关系表达出来，同时没有依赖关系的任务还可以并行执行。
一个DAG可以表示一个任务流，一个任务流应该有Request， Response，一个任务流应该有开始节点与结束节点。一个DAG应该允许节点中存在SubDAG
任务之前必须可以传递数据，我们定义A->B为B依赖A，那么应该可以将A的执行结果传递给B。如果存在依赖关系{A->B, C->B},那么应该可以将A的结果合并C的结果。
由于在Gateway中使用，任务的主要实现应该为 Http请求， RPCX请求， GRPC请求等，一个问题在于如何将客户端的Http请求转化为后端服务请求，通常的情况是，一个Http请求的query string或者body加上一些用户信息传递到后端服务，但是由于接口是从已经开发完成的系统中迁移，所以情况可能会较为复杂。Query String, Params, Header, Body, JWT,这个都可能是参数的来源
认证与授权也可以当作节点来使用
如果任意一个节点失败，那么请求应该是失败的，并且返回错误信息给前端

基本设计

Request 包含http所有可能的信息，必须包含一个requestID，假如没有就生成一个
Response 主要包含body与header，两个部分， header中必须包含requestID
每一个接口(POST /api/username)对应一个DAG，这个DAG可以使用JSON/YAML配置
DAG的执行应该是异步的，每个Node可能在不同的协程中执行，DAG应该有一个Executor，这个Executor应该负责Node的开始执行，捕获Node执行完成信号，并且通知所有满足依赖关系的Node继续执行，直到结束节点执行完毕。这个Executor应该包含一个Context，并且在所有Node中共享这个Context
Node应该在一个协程池当中执行，一个Node完成后在Context中设置完成结果，并且通过channel通知Executor

Jared's Site

Rust Utility Traits

Utility Traits

Drop

Sized

Clone

Copy

Deref and DerefMut

AsRef和AsMut

Borrow和BorrowMut

From和Into

ToOwned

Cow

Rust Iterators

一个简单的例子

IntoInterator和Iterator

drain方法

标准库应用

Iterator适配器

map and filter

filter_map and flat_map

flatten

其他

Rust Struct

Struct

基本用法

内部可变性

Rust Shared And Mutable References

共享引用与可变引用

共享引用期间不能修改

可变引用期间不能问

从共享引用reborrow

从可变引用reborrow

对象海

Rust References

引用类型

使用引用

隐式解引用/隐式借引用

嵌套引用

引用比较/计算

胖指针

引用安全

引用作为函数入参

引用作为函数返回

结构体包含引用

省略生命周期参数

后续

Rust Ownership And Move

背景

Ownership

Move

控制流中的Move

数组中的Move

Copy

Rc和Arc

Rust String Type

string和&str

内存布局

实现源码

str的其他使用方式

Box<str>

Cow<str>

MapReduce

系统描述

设计

实现

错误处理

流程图

任务流

需求描述

基本设计

`Drop`

`Sized`

`Clone`

`Copy`

`Deref` and `DerefMut`

`AsRef`和`AsMut`

`Borrow`和`BorrowMut`

`From`和`Into`

`ToOwned`

`Cow`

`IntoInterator`和`Iterator`

`drain`方法

`Iterator`适配器

`map` and `filter`

`filter_map` and `flat_map`

`flatten`

`其他`

从共享引用`reborrow`

从可变引用`reborrow`

省略`生命周期`参数

`Ownership`

`Move`

控制流中的`Move`

数组中的`Move`

`Rc`和`Arc`

`Box<str>`

`Cow<str>`