1. 函数式

rust迭代器是函数式范式实现的主体，回想一下函数式语言的几个关键特征：

• 高阶函数：函数可以作为参数传递给其他函数，也可以作为返回值。这允许函数式程序员编写更加模块化和可重用的代码。
• 惰性求值：函数式编程中的表达式只有在需要时才进行求值，这可以帮助提高程序的效率。
• 函数组合：函数可以被组合在一起形成新的函数，这可以使代码更加模块化和可重用。
• 类型系统和类型推断：函数式编程语言通常具有强大的类型系统，这可以帮助减少运行时错误和提高代码的安全性。

可以和rust实现函数式对应一下。

• 类型系统和类型推断 -> rust的patten，match =>
• 高阶函数 -> rust函数作为返回值，闭包
• 函数组合 -> 迭代器map/filter..
• 惰性求值 -> 迭代器collect/foreach..

学习rust函数式，要和Java8进行类比对比，两者实现有异曲同工。

2. rust迭代器

2.1 Iterator和IntoIterator

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    …… // 很多默认方法
}
trait IntoIterator where Self::IntoIter: Iterator<Item=Self::Item> {
    type Item;
    type IntoIter: Iterator;
    fn into_iter(self) -> Self::IntoIter;
}

Iterator和IntoIterator是迭代器的构造方法，要实现自己的迭代器，只要实现Iterator方法。例如vec的迭代器创建

let v = vec![4, 20, 12, 8, 6];
let mut iterator = v.iter();
let mut iterator1 = v.iter_mut()；

iter方法创建一个迭代器，将消耗vec中的值，iter_mut创建一个迭代器，迭代取vec中值的引用。

for element in &collection { ... }
for element in &mut collection { ... }
for element in collection { ... }

for语句会自动翻译为 (&collection).into_iter(), (&mut collection).into_iter, collection.into_iter();

• (&collection).into_iter() 会返回一个 Item 类型为 &T 的迭代器。该迭代器会生成对其条目的共享引用
• (&mut collection).into_iter() 会返回一个 Item 类型为 &mut T的迭代器。给定对集合的可变引用，into_iter 会返回一个迭代器，该迭代器会生成对其条目的可变引用。.
• collection.into_iter()返回迭代器，该迭代器会获取集合的所有权并按值返回这些条目，这些条目的所有权会从集合转移给消费者，原始集合在此过程中已被消耗掉了。

2.2 迭代器惰性

2.2.1 filter和map

let text = "  ponies  \n   giraffes\niguanas  \nsquid".to_string();
let v: Vec<&str> = text.lines()
    .map(str::trim)
    .filter(|s| *s != "iguanas")
    .collect();
assert_eq!(v, ["ponies", "giraffes", "squid"]);

filter 会返回第三个迭代器，它只会从 map 迭代器的结果中生成闭包 |s| *s != "iguanas" 返回 true 的那些条目

2.2.2 filter_map和flat_map

fn filter_map<B, F>(self, f: F) -> impl Iterator<Item=B>
    where Self: Sized, F: FnMut(Self::Item) -> Option<B>;
use std::str::FromStr;

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());
}

fiter_map与filter的不同是返回值是Option。

fn flat_map<U, F>(self, f: F) -> impl Iterator<Item=U::Item>
    where F: FnMut(Self::Item) -> U, U: IntoIterator;

use std::collections::HashMap;

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);
}

flat_map取出vec，并将vec数组展平为一个数组

2.2.3 take

fn take(self, n: usize) -> impl Iterator<Item=Self::Item>
    where Self: Sized;

fn take_while<P>(self, predicate: P) -> impl Iterator<Item=Self::Item>
    where Self: Sized, P: FnMut(&Self::Item) -> bool;

let message = "To: jimb\r\n\
               From: superego <editor@oreilly.com>\r\n\
               \r\n\
               Did you get any writing done today?\r\n\
               When will you stop wasting time plotting fractals?\r\n";
for header in message.lines().take_while(|l| !l.is_empty()) {
    println!("{}" , header);
}

take取第0-n行数据，take_while取满足predicate的数据。

2.2.4 zip

use std::iter::repeat;

let endings = ["once", "twice", "chicken soup with rice"];
let rhyme: Vec<_> = repeat("going")
    .zip(endings)
    .collect();
assert_eq!(rhyme, vec![("going", "once"),
                       ("going", "twice"),
                       ("going", "chicken soup with rice")]);

zip将两个迭代器组合成一个迭代器

2.3 迭代器求值

如果没有求值函数，则迭代器就是惰性的，不会处理。

2.3.1 count、sum 和 product

use std::io::prelude::*;

fn main() {
    let stdin = std::io::stdin();
    println!("{}", stdin.lock().lines().count());
}

count计算迭代对象个数。

2.3.2 min和max

assert_eq!([-2, 0, 1, 0, -2, -5].iter().max(), Some(&1));
assert_eq!([-2, 0, 1, 0, -2, -5].iter().min(), Some(&-5));

min和max求最大和最小值

2.3.3 any和all

let id = "Iterator";

assert!( id.chars().any(char::is_uppercase));
assert!(!id.chars().all(char::is_uppercase));

any和all表达了任意和所有的语义。

2.3.4 fold

let a = [5, 6, 7, 8, 9, 10];

assert_eq!(a.iter().fold(0, |n, _| n+1), 6);        // 计数
assert_eq!(a.iter().fold(0, |n, i| n+i), 45);       // 求和
assert_eq!(a.iter().fold(1, |n, i| n*i), 151200);   // 乘积

// 最大值
assert_eq!(a.iter().cloned().fold(i32::min_value(), std::cmp::max),
           10);

fold实现累加器

2.3.5 collection

use std::collections::;

let args: HashSet<String> = std::env::args().collect();
let args: BTreeSet<String> = std::env::args().collect();
let args: LinkedList<String> = std::env::args().collect();

// 只有键–值对才能收集到Map中，因此对于这个例子，
// 要把字符串序列和整数序列拉合在一起
let args: HashMap<String, usize> = std::env::args().zip(0..).collect();
let args: BTreeMap<String, usize> = std::env::args().zip(0..).collect();

// 其他代码略

colleciton构建集合

2.3.5 for_each

["doves", "hens", "birds"].iter()
    .zip(["turtle", "french", "calling"])
    .zip(2..5)
    .rev()
    .map(|((item, kind), quantity)| {
        format!("{} {} {}", quantity, kind, item)
    })
    .for_each(|gift| {
        println!("You have received: {}", gift);
    });

for_each遍历迭代对象

小结

rust的迭代器，对照Java8，很容易轻车熟路。学习迭代器，不要仅仅把迭代器当做一个设计模式或者rust的模块学习，要提升到函数式范式的层次来学习，这是快速掌握一门新语言的诀窍。