这本书很不错抄书笔记

3.类型系统

3.1 通用概念

对信息的存储和处理不止类型系统这一种方式，还有其他的一些理论框架，只不过类型系统是最轻量、最完善的一种方式
在类型系统中，一切皆类型。基于类型定义的一系列组合、运算和转换等方法，可以看作类型的行为
类型的行为决定了类型该如何计算，同时也是一种约束，有了这种约束才可以保证信息被正确处理
所谓类型，其实就是对表示信息的值进行的细粒度的区分

3.1.1类型系统的作用

排查错误。很多编程语言都会在编译期或运行期进行类型检查，以排查违规行为，保证程序正确执行。如果程序中有类型不一致的情况，或有未定义的行为发生，则可能导致错误的产生。尤其是对于静态语言来说，能在编译期排查出错误是一个很大的优势，这样可以及早地处理问题，而不必等到运行后系统崩溃了再解决
抽象。类型允许开发者在更高层面进行思考，这种抽象能力有助于强化编程规范和工程化系统。比如，面向对象语言中的类就可以作为一种类型。
文档。在阅读代码的时候，明确的类型声明可以表明程序的行为
优化效率。这一点是针对静态编译语言来说的，在编译期可以通过类型检查来优化一些操作，节省运行时的时间。
类型安全
- 类型安全的语言可以避免类型间的无效计算
- 类型安全的语言还可以保证内存安全
- 类型安全的语言也可以避免语义上的逻辑错误

3.1.2 类型系统的分类

在编译期进行类型检查的语言属于静态类型，在运行期进行类型检查的语言属于动态类型
如果一门语言不允许类型的自动隐式转换，在强制转换前不同类型无法进行计算，则该语言属于强类型，反之则属于弱类型
静态类型的语言能在编译期对代码进行静态分析，依靠的就是类型系统
强大的类型系统也可以对类型进行自动推导，因此一些静态语言在编写代码的时候不用显式地指定具体的类型，
Rust属于显式静态类型

3.1.3 类型系统与多态性

如果一个类型系统允许一段代码在不同的上下文中具有不同的类型，这样的类型系统就叫作多态类型系统
现代编程语言包含了三种多态形式：参数化多态（Parametric polymorphism）、Ad-hoc多态（Ad-hoc polymorphism）和子类型多态（Subtype polymorphism）
如果按多态发生的时间来划分，又可分为静多态（Static Polymorphism）和动多态（Dynamic Polymorphism）
静多态发生在编译期，动多态发生在运行时。
参数化多态和 Ad-hoc多态一般是静多态，子类型多态一般是动多态
静多态牺牲灵活性获取性能，动多态牺牲性能获取灵活性
Rust语言同时支持静多态和动多态，静多态就是一种零成本抽象
动多态在运行时需要查表，占用较多空间，所以一般情况下都使用静多态
参数化多态实际就是指泛型
Ad-hoc多态也叫特定多态。
Ad-hoc多态是指同一种行为定义，在不同的上下文中会响应不同的行为实现
Rust受Haskell启发，使用trait来支持Ad-hoc多态。所以，Rust的trait 系统的概念类似于Haskell中的Typeclass
子类型多态的概念一般用在面向对象语言中，尤其是Java语言。 Java语言中的多态就是子类型多态
而 Rust语言中并没有类似Java 中的继承的概念，所以也不存在子类型多态
所以，Rust中的类型系统目前只支持参数化多态和Adhoc多态，也就是，泛型和trait。

3.2 Rust类型系统概述

Rust是一门强类型且类型安全的静态语言
Rust中一切皆表达式，表达式皆有值，值皆有类型。所以可以说，Rust中一切皆类型。
除了一些基本的原生类型和复合类型，Rust把作用域也纳入了类型系统，这就是生命周期标记
把作用域也纳入了类型系统，这就是第4章将要学到的生命周期标记。还有一些表达式，有时有返回值，有时没有返回值（也就是只返回单元值），或者有时返回正确的值，有时返回错误的值，Rust 将这类情况也纳入了类型系统，也就是Option＜T＞和Result＜T，E＞这样的可选类型
些根本无法返回值的情况，比如线程崩溃、 break或continue等行为，也都被纳入了类型系统，这种类型叫作never类型

3.2.1 类型大小

所以编译器需要事先知道类型的大小，才能分配合理的内存
Rust提供了引用类型，因为引用总会有固定的且在编译期已知的大小
这种包含了动态大小类型地址信息和携带了长度信息的指针，叫作胖指针（Fat Pointer）
Rust中的数组[T]是动态大小类型，编译器难以确定它的大小
除了可确定大小类型和DST类型，Rust还支持零大小类型（Zero Sized Type，ZST）
ZST类型的特点是，它们的值就是其本身，运行时并不占用内存空间。ZST类型代表的意义正是“空”。
底类型（Bottom Type）是源自类型理论的术语，它其实是第2章介绍过的never类型
- 没有值。
- 是其他任意类型的子类型
如果说ZST类型表示“空”的话，那么底类型就表示“无”
Rust中的底类型用叹号（！）表示。此类型也被称为Bang Type。
- 发散函数（Diverging Function）
- continue和break关键字
- loop循环
- 空枚举，比如enum Void{}
发散函数是指会导致线程崩溃的 panic!("This function never returns!")，或者用于退出函数的st:: process::exit，这类函数永远都不会有返回值
continue和break也是类似的，它们只是表示流程的跳转，并不会返回什么
loop循环虽然可以返回某个值，但也有需要无限循环的时候
Rust中if语句是表达式，要求所有分支类型一致
但是有的时候，分支中可能包含了永远无法返回的情况，属于底类型的一种应用

3.2.2 类型推导

Rust支持类型推断，但其功能并不像Haskell那样强大，Rust只能在局部范围内进行类型推导
turbofish操作符。parse::＜i32>()这样的形式为泛型函数标注类型
目前看来，Rust的类型推导还不够强大

3.3泛型

目前看来，Rust的类型推导还不够强大
简单来说，泛型就是把一个泛化的类型作为参数，单个类型就可以抽象化为一簇类型

3.3.1 泛型函数

Rust中的泛型属于静多态，它是一种编译期多态。在编译期，不管是泛型枚举，还是泛型函数和泛型结构体，都会被单态化（Monomorphization）
单态化是编译器进行静态分发的一种策略
单态化静态分发的好处是性能好，没有运行时开销；缺点是容易造成编译后生成的二进制文件膨胀

3.3.2 泛型返回值自动推导

3.4 深入trait

可以说trait是Rust的灵魂.Rust中所有的抽象,比如接口抽象, OOP范式抽象、函数式范式抽象等，均基于trait来完成。
同时，trait也保证了这些抽象几乎都是运行时零开销的。
从类型系统的角度来说，trait是Rust对Adhoc多态的支持
从语义上来说，trait是在行为上对类型的约束，这种约束可以让trait有如下4种用法
- 接口抽象。接口是对类型行为的统一约束。
- 泛型约束。泛型的行为被trait限定在更有限的范围内。
- 抽象类型。在运行时作为一种间接的抽象类型去使用，动态地分发给具体的类型
- 标签trait。对类型的约束，可以直接作为一种“标签”使用

3.4.1 接口抽象

接口中可以定义方法，并支持默认实现
接口中不能实现另一个接口，但是接口之间可以继承。
同一个接口可以同时被多个类型实现，但不能被同一个类型实现多次
使用impl关键字为类型实现接口方法
使用trait关键字来定义接口
为不同的类型实现 trait，属于一种函数重载，也可以说函数重载就是一种 Ad-hoc多态
这是因为Rust遵循一条重要的规则：孤儿规则（Orphan Rule）。
孤儿规则规定，如果要实现某个trait，那么该trait和要实现该trait的那个类型至少有一个要在当前crate中定义。
Rust不支持传统面向对象的继承，但是支持trait继承。

3.4.2 泛型约束

3.4.3 抽象类型

相对于具体类型而言，抽象类型无法直接实例化，它的每个实例都是具体类型的实例

3.5 类型转换

隐式类型转换是由编译器或解释器来完成的，开发者并未参与，所以又称之为强制类型转换（Type Coercion）
在编程语言中，类型转换分为隐式类型转换（Implicit Type Conversion）和显式类型转换（Explicit Type Conversion）
只要不乱用unsafe块来跳过编译器检查，就不会因为类型转换出现安全问题

3.5.1 Deref解引用

自动解引用虽然是编译器来做的，但是自动解引用的行为可以由开发者来定义
Deref 有一个特性是强制隐式转换
规则是这样的：如果一个类型 T实现了Deref＜Target=U＞，则该类型T的引用（或智能指针）在应用的时候会被自动转换为类型U
是String类型实现了Deref＜ Target=str＞
当某类型和其解引用目标类型中包含了相同的方法时，编译器就不知道该用哪一个了

3.5.2 as操作符

as 操作符最常用的场景就是转换 Rust 中的基本数据类型

3.5.3 from和into

From和Into是定义于std：：convert模块中的两个trait。它们定义了 from和into两个方法，这两个方法互为反操作
对于类型T，如果它实现了From＜U＞，则可以通过T：： from（u）来生成T类型的实例，
对于类型T，如果它实现了Into＜U＞，则可以通过into方法来消耗自身转换为类型U的新实例
关于Into有一条默认的规则：如果类型U实现了From＜T＞，则T 类型实例调用into方法就可以转换为类型U。

4. 内存管理

按照内存的管理方式可将编程语言大致分为两类：手动内存管理类和自动内存管理类。
手动内存管理的优势在于性能，因为可以直接操控内存，但同时也带来不少问题
GC 自动内存管理接管了开发者分配和回收内存的任务，并帮助提升了代码的抽象度和可靠性
GC 最大的问题是会引起“世界暂停”，GC 在工作的时候必须保证程序不会引入新的“垃圾”，所以要使运行中的程序暂停，这就造成了性能问题

4.1 通用概念

Rust编译器目前自带两个默认分配器：alloc_system和 alloc_jemalloc
在Rust 2015版本下，编译器产生的二进制文件默认使用alloc_jemalloc（某些平台可能不支持jemalloc），而对于静态或动态链接库，默认使用alloc_system。在Rust 2018版本下，默认使用 alloc_system，并且可以由开发者自己指派Jemalloc或其他第三方分配器。
Jemalloc的优势有以下几点
- 分配或回收内存更快速
- 内存碎片更少。
- 多核友好
- 良好的可伸缩性
能放在栈上的数据最好不要放到堆上。因此，Rust的类型默认都是放到栈上
CPU在单位时间内能处理的一组二进制数称为字，这组二进制数的位数称为字长
因为对齐的是字节，所以内存对齐也叫字节对齐
内存对齐是编译器或虚拟机（比如JVM）的工作，不需要人为指定

4.2 Rust资源管理

Rust 可以静态地在编译时确定何时需要释放内存，而不需要在运行时去确定
Rust有一套完整的内存管理机制来保证资源的合理利用和良好的性能

4.2.1 变量和函数

变量有两种：全局变量和局部变量。全局变量分为常量变量和静态变量
局部变量是指在函数中定义的变量。
常量使用const关键字定义，并且需要显式指明类型，只能进行简单赋值，只能使用支持CTFE的表达式
常量没有固定的内存地址，因为其生命周期是全局的，随着程序消亡而消亡，并且会被编译器有效地内联到每个使用到它的地方
静态变量使用static关键字定义，跟常量一样需要显式指明类型，进行简单赋值，而不能使用任何表达式
静态变量的生命周期也是全局的，但它并不会被内联，每个静态变量都有一个固定的内存地址
静态变量并非被分配到栈中，也不是在堆中，而是和程序代码一起被存储于静态存储区中
在函数中定义的局部变量都会被默认存储到栈中，Rust编译器可以检查未初始化的变量，以保证内存安全
当变量绑定空的数组或向量时，需要显式指定类型，否则编译器无法推断其类型
转移所有权产生了未初始化变量
使用智能指针，可以让 Rust利用栈来隐式自动释放堆内存，从而避免显式调用free之类的函数去释放内存。

4.2.2 智能指针与RALL

Rust中的指针大致可以分为三种：引用、原生指针（裸指针）和智能指针
引用就是Rust提供的普通指针.和原生指针差异如下
- 可以通过as操作符随意转换，例如&T as *const T和&mut T as *mut T
- 原生指针可以在 unsafe 块下任意使用，不受 Rust 的安全检查规则的限制，而引用则必须受到编译器安全检查规则的限制。
智能指针（smart pointer）实际上是一种结构体，只不过它的行为类似指针
智能指针是对指针的一层封装，提供了一些额外的功能，比如自动释放堆内存
智能指针区别于常规结构体的特性在于，它实现了 Deref和Drop 这两个trait。Deref提供了解引用能力，Drop提供了自动析构的能力，正是这两个trait让智能指针拥有了类似指针的行为
类型决定行为，同时类型也取决于行为，不是指针胜似指针，所以称其为智能指针
Drop对于智能指针来说非常重要，因为它可以帮助智能指针在被丢弃时自动执行一些重要的清理工作，比如释放堆内存.
Drop还可以做很多其他的工作，比如释放文件和网络连接。
Drop的功能有点类似GC，但它比GC的应用更加广泛，GC只能回收内存，而Drop可以回收内存及内存之外的一切资源
确定性析构（RALL）意思是资源获取及初始化
RAII和智能指针均起源于现代C++，智能指针就是基于RAII机制来实现的
RAII的机制是使用构造函数来初始化资源，使用析构函数来回收资源
但RAII 和GC最大的不同在于，RAII将资源托管给创建堆内存的指针对象本身来管理，并保证资源在其生命周期内始终有效，一旦生命周期终止，资源马上会被回收
而GC是由第三方只针对内存来统一回收垃圾的，这样就很被动
Rust中的Drop就是析构函数（Destructor）。
Rust中并没有现代C++所拥有的那种构造函数（constructor），而是直接对每个成员的初始化来完成构造，也可以直接通过封装一个静态函数来构造“构造函数”
RAII也有另外一个别名，叫作用域界定的资源管理（Scope-Bound Resource Management，SBRM）。
析构函数调用顺序是在编译期（而非运行时）就确定好的
这是因为Rust编译器使用了名为drop-flag的“魔法”，在函数调用栈中为离开作用域的变量自动插入布尔标记，标注是否调用析构函数
对于结构体或枚举体这种复合类型来说，并不存在隐式的dropflag
只有在函数调用时，这些复合结构实例被初始化之后，编译器才会加上drop-flag
如果复合结构本身实现了Drop，则会调用它自己的析构函数；否则，会调用其成员的析构函数
当变量被绑定给另外一个变量，值发生移动时，也会被加上dropflag，在运行时会调用析构函数
可以使用花括号构造显式作用域来“主动析构”那些需要提前结束生命周期的变量
对于实现Copy的类型，是没有析构函数的。因为实现了Copy的类型会复制，其生命周期不受析构函数的影响
变量遮蔽（shadowing）并不会导致其生命周期提前结束，

4.2.3 内存泄漏与内存安全

Rust 提供了另外一个智能指针RefCell＜T＞，它提供了一种内部可变性，这意味着，它对编译器来说是不可变的，但在运行过程中，包含在其中的内部数据是可变的
Rust并不能百分百地阻止内存泄漏，但也不是轻而易举就可以造成内存泄漏的
内存泄漏（Memory Leak）并不在内存安全（Memory Safety）概念范围内
- 使用未定义内存
- 空指针。
- 缓冲区溢出。
- 悬垂指针。
- 非法释放未分配的指针或已经释放过的指针
Rust中的变量必须初始化以后才可使用，否则无法通过编译器检查
悬垂指针（dangling pointer）是指堆内存已被释放，但其本身还没有做任何处理，依旧指向已回收内存地址的指针
在Rust中可导致内存泄漏的情况大概有以下三种：
- 线程崩溃，析构函数无法调用。
- 使用引用计数时造成了循环引用。
- 调用Rust标准库中的forget函数主动泄漏。
- 以上三种情况从本质上说就是，Rust并不会保证百分之百调用析构函数

4.2.4 复合类型的内存分配和布局

struct A {
  a: u32,
  b: Box<u64>,
}

l5d3oc

struct B(i32, f64, char);
struct N;

结构体 B 为元组结构体，其对齐规则和普通结构体一样，所以占16个字节
结构体N为单元结构体，占0个字节

enum E {
  H(32),
  M(Box<u32>),
}

4l2sqm

5.所有权系统

栈内存的生命周期是短暂的，会随着栈展开（常见的是函数调用）的过程而被自动清理
而堆内存是动态的，其分配和重新分配并不遵循某个固定的模式，所以需要使用指针来对其进行跟踪
智能指针在堆上开辟内存空间，并拥有其所有权，通过存储于栈中的指针来管理堆内存
智能指针的RAII机制利用栈的特点,在栈元素被自动清空时自动调用析构函数，来释放智能指针所管理的堆内存空间。
C++中的RAII机制虽然也有所有权的概念，但其作用范围非常有限，仅智能指针有所有权，并且现代C++编译器也并没有依据所有权进行严格检查
而在Rust中，所有权是系统性的概念，是Rust语言中的基础设施。Rust中的每个值都必定有一个唯一控制者，所有者

5.1 通用概念

当今计算机内存栈和堆的分配机制，决定了编程语言中的值主要分为两类：值类型（Value）和引用类型（Reference）。
值类型是指数据直接存储在栈中的数据类型，一些原生类型，比如数值、布尔值、结构体等都是值类型
值类型作为右值（在值表达式中）执行赋值操作时，会自动复制一个新的值副本。
引用类型将数据存储在堆中，而栈中只存放指向堆中数据的地址（指针），比如数组、字符串等
但随着语言的发展，类型越来越丰富，值类型和引用类型已经难以描述全部情况，为了更加精准地对这种情况进行描述，值语义（Value Semantic）和引用语义（Reference Semantic）被引入
值语义：按位复制以后，与原始对象无关。
引用语义：也叫指针语义。一般是指将数据存储于堆内存中，通过栈内存的指针来管理堆内存的数据，并且引用语义禁止按位复制。
按位复制就是指栈复制，也叫浅复制，它只复制栈上的数据。
深复制就是对栈上和堆上的数据一起复制。
值语义可以保证变量值的独立性（Independence）。独立性的意思是，如果想修改某个变量，只能通过它本身来修改；而如果修改了它本身，并不影响其复制品。也就是说，如果只能通过变量本身来修改值，那么它就是具有值语义的变量
而Rust通过Copy这个标记trait，将类型按值语义和引用语义做了精准的分类，帮助编译器检测出潜在的内存安全问题
虽然引用语义类型不能实现Copy，但可以实现 Clone的clone方法，以实现深复制，在需要的时候可以显式调用

5.2 所有权机制

Rust 也引入了新的语义：复制（Copy）语义和移动（Move）语义。复制语义对应值语义，移动语义对应引用语义。这样划分是因为引入了所有权机制，在所有权机制下同时保证内存安全和性能。
一个值的所有权被转移给另外一个变量绑定的过程，就叫作所有权转移。
Rust中分配的每块内存都有其所有者，所有者负责该内存的释放和读写权限，并且每次每个值只能有唯一的所有者。这就是 Rust的所有权机制（OwnerShip）。所有权的类型系统理论
Rust的所有权在类型系统理论中称为仿射类型（affine type），它属于类型理论中子结构类型系统（ Substructural Type System）的概念
子结构类型系统又是子结构逻辑（Substructural Logic）在类型系统中的应用
而子结构逻辑属于证明理论里的推理规则，其规则包含如下几点。
- 线性逻辑（Linear Logic），如果某个变量符合某种特定的“结构”，它就内含一种规则：必须且只能使用一次。
- 仿射逻辑（Affine Logic），最多使用一次，也就是说，可以使用0次或1次。看上去线性逻辑更严格一些
所有权的特点所有者拥有以下三种权限
- 控制资源（不仅仅是内存）的释放
- 出借所有权，包括不可变（共享）的和可变（独占）的。
- 转移所有权。
在进行赋值操作时，作为右值的变量会默认执行移动语义来转移所有权，从而保证了内存安全
对于复合类型来说，是复制还是移动，取决于其成员的类型,但是Rust并不会默认为其实现Copy
枚举体和结构体是类似的，当成员均为复制语义类型时，不会自动实现Copy。
对于元组类型来说，其本身实现了Copy，如果元素均为复制语义类型，则默认是按位复制的，否则会执行移动语义
数组和Option类型与元组类型都遵循这样的规则：如果元素都是复制语义类型，也就是都实现了Copy，那么它们就可以按位复制，否则就转移所有权

5.3 绑定、作用域和生命周期

let a = b因为a是String类型，不能实现 Copy，所以这种行为其实也可以理解为对a进行解绑，然后重新绑定给 b。

5.3.1 不可变与可变

共享可变状态是万恶之源
可变状态绝不能共享，否则会增加函数之间的耦合度，函数中的变量状态在任何时候发生改变都将变得难以控制，从而让函数产生“副作用”。可变状态也更不利于多线程并发程序，容易引发数据竞争
- 多线程并发时，不可变的数据可以安全地在线程间共享。
- 函数的“副作用”可以得到控制

5.3.2 绑定的时间属性生命周期

变量绑定具有“时空”双重属性。
- 空间属性是指标识符与内存空间进行了绑定
- 时间属性是指绑定的时效性，也就是指它的生存周期。
一个绑定的生存周期也被称为生命周期（lifetime），是和词法作用域有关的
每个 let 声明都会创建一个默认的词法作用域，该作用域就是它的生命周期
绑定的析构顺序和声明顺序相反
目前Rust的生命周期是基于词法作用域的，编译器能自动识别函数内部这些局部变量绑定的生命周期
当向绑定在词法作用域中传递的时候，就会产生所有权的转移
在match语句内部，每个匹配分支都是独立的词法作用域
for、loop以及while循环语句均可以创建新的作用域
if let块和while let块也会创建新的作用域
函数体本身是独立的词法作用域
闭包会创建新的作用域，对于环境变量来说有以下三种捕获方式：
- 对于复制语义类型，以不可变引用（&T）来捕获。
- 对于移动语义类型，执行移动语义（move）转移所有权来捕获。
- 对于可变绑定，如果在闭包中包含对其进行修改的操作，则以可变引用（&mut）来捕获

5.4 所有权借用

是函数参数签名也支持模式匹配，相当于使用 let 将 v 重新声明成了可变绑定。
使用可变借用的前提是，出借所有权的绑定变量必须是一个可变绑定
引用（Reference）是 Rust 提供的一种指针语义
用是基于指针的实现，它与指针的区别是，指针保存的是其指向内存的地址，而引用可以看作某块内存的别名（Alias），使用它需要满足编译器的各种安全检查规则
在所有权系统中，引用&x也可称为x的借用（Borrowing），通过 &操作符来完成所有权租借
借用所有权会让所有者（owner）受到如下限制：
- 在不可变借用期间，所有者不能修改资源，并且也不能再进行可变借用。
- 在可变借用期间，所有者不能访问资源，并且也不能再出借所有权。
引用在离开作用域之时，就是其归还所有权之时。
为了保证内存安全，借用必须遵循以下三个规则
- 规则一：借用的生命周期不能长于出借方（拥有所有权的对象）的生命周期
- 规则二：可变借用（引用）不能有别名（Alias），因为可变借用具有独占性
- 规则三：不可变借用（引用）不能再次出借为可变借用。
规则一是为了防止出现悬垂指针。规则二和三可以总结为一条核心的原则：共享不可变，可变不共享
不可变借用可以被出借多次，因为它不能修改内存数据，因此它也被称为共享借用（引用），可变借用只能出借一次，否则，难以预料数据何时何地会被修改。
Rust的借用检查带来了如下好处：
- 不可变借用保证了没有任何指针可以修改值的内存，便于将值存储在寄存器中
- 可变借用保证了在写的时候没有任何指针可以读取值的内存，避免了脏读。
- 不可变借用保证了内存不会在读取之后被写入新数据。
- 保证了不可变借用和可变借用不相互依赖，从而可以对读写操作进行自由移动和重新排序
解引用操作会获得所有权

5.5 生命周期参数

5.5.1 显示生命周期参数

值的生命周期和词法作用域有关，但是借用可以在各个函数间传递，必然会跨越多个词法作用域
函数或方法参数的生命周期叫作输入生命周期（input lifetime），而返回值的生命周期被称为输出生命周期（output lifetime）
输出（借用方）的生命周期长度必须不长于输入（出借方）的生命周期长度（此条件依然遵循借用规则一）。
禁止在没有任何输入参数的情况下返回引用，因为明显会造成悬垂指针
从函数中返回（输出）一个引用，其生命周期参数必须与函数的参数（输入）相匹配，否则，标注生命周期参数也毫无意义
输入引用和输出引用都标记为＇a，意味着输出引用（借用方）的生命周期不长于输入引用（出借方）的生命周期
生命周期参数是为了帮助借用检查器验证非法借用。函数间传入和返回的借用必须相关联
生命周期参数单态化
生命周期参数的目的是帮助借用检查器验证合法的引用，消除悬垂指针
对于所有允许使用&＇a str类型的地方，使用&＇static str也是合法的
Rust中的生命周期参数并非类型
结构体在含有引用类型成员的时候也需要标注生命周期参数
结构体实例的生命周期应短于或等于任意一个成员的生命周期。

5.5.2 省略生命周期参数

Rust针对某些场景确定了一些常见的模式，将其硬编码到 Rust编译器中，以便编译器可以自动补齐函数签名中的生命周期参数，这样就可以省略生命周期参数
被硬编码进编译器的模式称为生命周期省略规则（Lifetime Elision Rule），一共包含三条规则
- 每个输入位置上省略的生命周期都将成为一个不同的生命周期参数
- 如果只有一个输入生命周期的位置（不管是否忽略），则该生命周期都将分配给输出生命周期。
- 如果存在多个输入生命周期的位置，但是其中包含着&self或&mut self，则self的生命周期都将分配给输出生命周期。

fn print(s: &str);                                           // 省略
fn print<'a>(s: &'a str);                                   // 展开
fn debug(lvl: uint, s: &str);                              // 省略
fn debug<'a>(lvl: uint, s: &'a str);                      // 展开
fn substr(s: &str, until: uint) -> &str;                 // 省略
fn substr<'a>(s: &'a str, until: uint) -> &'a str;     // 展开
fn get_str() -> &str;                                   // 非法
fn frob(s: &str, t: &str) -> &str;                    // 非法
fn get_mut(&mut self) -> &mut T;                           // 省略
fn get_mut<'a>(&'a mut self) -> &'a mut T;              // 展开
/// // 省略
fn args<T:ToCStr>(&mut self, args: &[T]) -> &mut Command
/// // 展开
fn args<'a, 'b, T:ToCStr>(&'a mut self, args: &'b [T]) -> &'a mut Command
fn new(buf: &mut [u8]) -> BufWriter;                      // 省略
fn new<'a>(buf: &'a mut [u8]) -> BufWriter<'a>          // 展开

5.5.3 生命周期限定

T:'a 表示T类型中的任何引用都要“活得”和'a一样长。
T:Trait+'a，表示T类型必须实现Trait这个trait，并且T类型中任何引用都要“活得”和＇a一样长

5.5.4 trait对象的生命周期

TODO

6 函数，闭包和迭代器

6.1 函数

fn 关键字后面为函数名称，通常以蛇形命名法（snake_case）命名，否则编译器会发出警告
Rust中的函数参数不能指定默认值
函数参数必须明确地指定类型，如果有返回值也必须指定返回值的类型
函数体被包含于花括号之内，除函数体之外的函数声明被称为函数签名
通过将原生标识操作符（Raw Identifier）r＃作为前缀，即可使用关键字为函数命名，该语法一般用于 FFI中
函数参数可以按值传递，也可以按引用传递
当参数按引用传递时，所有权不会发生变化，但是需要有生命周期参数。当符合生命周期参数省略规则时，编译器可以通过自动推断补齐函数参数的生命周期参数，否则，需要显式地为参数标明生命周期参数。
Rust的函数参数默认不可变，当需要可变操作的时候，需要使用mut关键字来修饰

6.1.1 函数屏蔽

当声明变量绑定之后，如果再次声明同名的变量绑定，则之前的变量绑定会被屏蔽，这叫作变量屏蔽（variable shadow
在同一个作用域中不能定义多个同名函数,因为默认的函数定义只在当前作用域内有效，会屏蔽作用域外的同名函数

6.1.2 函数参数的匹配模式

函数中的参数等价于一个隐式的let绑定，而let绑定本身是一个模式匹配的行为。所以函数参数也支持模式匹配
TODO

6.1.3函数返回值

Rust中的函数只能有唯一的返回值，即便是没有显式返回值的函数，其实也相当于返回了一个单元值（）
对于只需要返回函数体最后一行表达式所求值的函数，return可以省略
函数返回值类型为“！”的发散函数（diverging function），这类函数将永远不会有任何返回值

zoniony / zoniony.github.io

rust抄书之道 #3

3.类型系统

3.1 通用概念

3.1.1类型系统的作用

3.1.2 类型系统的分类

3.1.3 类型系统与多态性

3.2 Rust类型系统概述

3.2.1 类型大小

3.2.2 类型推导

3.3泛型

3.3.1 泛型函数

3.3.2 泛型返回值自动推导

3.4 深入trait

3.4.1 接口抽象

3.4.2 泛型约束

3.4.3 抽象类型

3.5 类型转换

3.5.1 Deref解引用

3.5.2 as操作符

3.5.3 from和into

4. 内存管理

4.1 通用概念

4.2 Rust资源管理

4.2.1 变量和函数

4.2.2 智能指针与RALL

4.2.3 内存泄漏与内存安全

4.2.4 复合类型的内存分配和布局

5.所有权系统

5.1 通用概念

5.2 所有权机制

5.3 绑定、作用域和生命周期

5.3.1 不可变与可变

5.3.2 绑定的时间属性 生命周期

5.4 所有权借用

5.5 生命周期参数

5.5.1 显示生命周期参数

5.5.2 省略生命周期参数

5.5.3 生命周期限定

5.5.4 trait对象的生命周期

6 函数，闭包和迭代器

6.1 函数

6.1.1 函数屏蔽

6.1.2 函数参数的匹配模式

6.1.3函数返回值

6.1.4 泛型函数

5.3.2 绑定的时间属性生命周期