前面章节参见：
深入RUST标准库内核（序言） - 简书 (jianshu.com)
深入RUST标准库内核(一 概述) - 简书 (jianshu.com)
深入RUST标准库内核(二 内存）—Layout/原生指针 - 简书 (jianshu.com)
深入RUST标准库内核（二 内存）—NonNull<T>/申请及释放 - 简书 (jianshu.com)
深入RUST标准库内核（二 内存）—mem模块/MaybeUninit<T> - 简书 (jianshu.com)
深入RUST标准库内核 (三 基础Trait) 编译器内置Trait - 简书 (jianshu.com)
深入RUST标准库内核（三 基础Trait）— Ops Trait - 简书 (jianshu.com)
深入RUST标准库内核（三 基本Trait）—Range - 简书 (jianshu.com)
深入RUST标准库内核（三 基础Trait）—Index Trait - 简书 (jianshu.com)
RUST的Iterator实现代码分析
Iterator在函数式编程中是居于最核心的地位。在函数式编程中，最关键的就是把问题的解决方式设计成能够使用Iterator方案来解决。RUST基本上可以说是原生的Iterator语言，几乎所有的核心关键类型的方法库都依托于Iterator。
RUST的Iterator与其他语言Iterator比较
RUST定义了三种迭代器Trait:
- 对容器内的变量进行操作的迭代器：
pub trait IntoIterator {
type Item;
type IntoIter: Iterator<Item = Self::Item>;
fn into_iter(self) -> Self::IntoIter;
}
into_iter返回的迭代器迭代时，会消费容器，完全迭代后容器将被释放。此种迭代器适用于类似生产者-消费者队列的程序设计
- 对容器内的变量不可用引用进行操作的迭代器：
这个一般不做Trait，而是容器类型实现一个方法：
pub fn iter(&self) -> I:Iterator
此方法返回一个迭代器，这种迭代器适用的一个例子是对网络接口做遍历以获得统计值 - 对容器内的变量可变引用进行操作的迭代器：
同2 容器类型实现方法：
pub fn iter_mut(&self) -> I:Iterator
这种迭代器适用的一个例子是定时器遍历长连接，更新连接活动时间。
其他语言中没有变量迭代器，这是RUST独有的所有权和drop机制带来的一种迭代器。在适合的场景下会缩减代码量及提高效率。
一般的，RUST对于实现上面三个Trait，要求额外实现下面的两种机制
T::iter() 等同于 &T::into_iter()
T::iter_mut() 等同于 &mut T::into_iter()
Iterator Trait 定义
pub trait Iterator {
/// 每次迭代时返回的变量类型.
type Item;
fn next(&mut self) -> Option<Self::Item>;
//size_hint返回值是此迭代器最少产生多少个有效迭代输出，最多产生多少有有效迭代输出。
//所以，诸如(0..10).int_iter(), 最少是10个，最多也是10个，
//而（0..10).filter(|x| x%2 == 0), 因为编译器不会提前计算，所以符合条件的最少可能是0个，最多是10个
fn size_hint(&self) -> (usize, Option<usize>) {
(0, None)
}
}
impl<I: Iterator + ?Sized> Iterator for &mut I {
type Item = I::Item;
fn next(&mut self) -> Option<I::Item> {
(**self).next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
(**self).size_hint()
}
fn advance_by(&mut self, n: usize) -> Result<(), usize> {
(**self).advance_by(n)
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
(**self).nth(n)
}
}
上面代码：如果一个类型I已经实现了 Iterator, 那针对这个结构的可变引用类型 &mut I, 标准库已经做了统一的 Iterator Trait实现。
ops::Range类型的Iterator实现
定义如下：
impl<A: Step> Iterator for ops::Range<A> {
...
}
只有实现Step Trait的Range类型才实现了Iterator, Step Trait的定义如下：
pub trait Step: Clone + PartialOrd + Sized {
/// 从start 到end一共多少step
fn steps_between(start: &Self, end: &Self) -> Option<usize>;
/// 向前count步返回值
fn forward_checked(start: Self, count: usize) -> Option<Self>;
/// 向前count步 返回值，出错退出
fn forward(start: Self, count: usize) -> Self {
Step::forward_checked(start, count).expect("overflow in `Step::forward`")
}
/// 向前不检查 count步
unsafe fn forward_unchecked(start: Self, count: usize) -> Self {
Step::forward(start, count)
}
/// 向后count步
fn backward_checked(start: Self, count: usize) -> Option<Self>;
/// 向后count步，出错退出
fn backward(start: Self, count: usize) -> Self {
Step::backward_checked(start, count).expect("overflow in `Step::backward`")
}
/// 向后count步，出错退出
unsafe fn backward_unchecked(start: Self, count: usize) -> Self {
Step::backward(start, count)
}
}
照此，可以实现一个自定义类型的类型, 并支持Step Trait，如此，即可使用Range的符号。例如，一个二维的点的range，三维的点的range，数列等。
一个为所有的无符号类型整数实现的Step Trait中的一个函数：
fn forward_checked(start: Self, n: usize) -> Option<Self> {
match Self::try_from(n) {
Ok(n) => start.checked_add(n),
Err(_) => None, // if n is out of range, `unsigned_start + n` is too
}
}
从这个函数中可以看到，使用了try_from做了不同的无符号整数类型之间的变换，checked_add来规避溢出，都是RUST的安全性的具体体现，这是使用rust编码与其他语言编码的不同之处,在编码的时候即强制消除了易忽视的整数变量溢出bug产生。
Range Iterator的底层实现Trait RangeIteratorImpl
impl<A: Step> RangeIteratorImpl for ops::Range<A> {
type Item = A;
default fn spec_next(&mut self) -> Option<A> {
if self.start < self.end {
//self.start.clone()是为了不转移self.start的所有权
let n =
Step::forward_checked(self.start.clone(), 1).expect("`Step` invariants not upheld");
//mem::replace将self.start赋值为n，返回self.start的值，这个方式适用于任何类型
Some(mem::replace(&mut self.start, n))
} else {
None
}
}
...
}
从代码分析中可见，rust在代码上的技巧性实际上和C在思想上很类似。都是基于对内存的深刻理解。
