Rust Lang Book Ch.13 Iterators, Closures

Closures

Closure是匿名函数，并且可以存下来。此外，Closure会获取创建时的作用域中的变量。

fn generate_workout(intensity: u32, random_number: u32) {
    let expensive_closure = |num| { //closure，以num为参数，返回num
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    };

    if intensity < 25 {
        println!("Today, do {} pushups!", expensive_closure(intensity));
        println!("Next, do {} situps!", expensive_closure(intensity));
    } else {
        if random_number == 3 {
            println!("Take a break today! Remember to stay hydrated!");
        } else {
            println!(
                "Today, run for {} minutes!",
                expensive_closure(intensity)
            );
        }
    }
}

　　

编译器会对Closure做一定程度的参数类型推理。

fn  add_one_v1   (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1  ;

　　

不过，一个Closure只能对应一套参数-返回值类型，编译器推理该Closure对应的类型之后，就会固定下来。

    let example_closure = |x| x;

    let s = example_closure(String::from("hello"));
    let n = example_closure(5);
                            ^
                            |
                            expected struct `std::string::String`, found integer
                            help: try using a conversion method: `5.to_string()`

　　

Closure至少实现了Fn, FnMut和FnOnce三种traits之中的一个。如果不需要创建Closure上下文中的变量，能传Closure的地方也能传Function

impl<T> Cacher<T>
where
    T: Fn(u32) -> u32,
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }

    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}

　　

FnOnce直接consume（也即拿走ownership）它所需要的创建上下文中的变量，当然要注意由于ownership只能拿一次，所以FnOnce也只能调用一次。

Fn则只读地从创建时的上下文中borrow values。

FnMut从创建时的上下文中borrow values，同时还能改这些变量。

fn main() {
    let x = 4;

    let equal_to_x = |z| z == x;//capture x

    let y = 4;

    assert!(equal_to_x(y));
}

　　

Rust编译器会根据Closure内容决定该Closure实现哪些traits。所有Closure都实现了FnOnce。对于不会发生Move，也就是不会发生Ownership改动的Closure，编译器会令其实现FnMut。对哪些不会更改captured variables的值的Closures，编译器会令其实现Fn。

如果一定要closure拿走它captured的variables的ownership，可以使用move关键字。

fn main() {
    let x = vec![1, 2, 3];

    let equal_to_x = move |z| z == x;

    let y = vec![1, 2, 3];

    assert!(equal_to_x(y));
}

　　

一般来说可以先试试用Fn来当trait bound，如果需要用FnMut或者FnOnce，编译器报错再改。

Iterator

 Iterator是懒计算的，可以用来遍历集合。

    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();

    for val in v1_iter {//这里不需要声明v1_iter为mutable，因为for循环自动帮我们标了
        println!("Got: {}", val);
    }

　　

所有的迭代器都实现了一个特性Iterator，Iterator实现了方法next()，返回一个包含子元素的Option，当迭代完成后，返回值为None，否则为Some(子元素)。

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // methods with default implementations elided
}

　　

    #[test]
    fn iterator_demonstration() {
        let v1 = vec![1, 2, 3];

        let mut v1_iter = v1.iter();

        assert_eq!(v1_iter.next(), Some(&1));
        assert_eq!(v1_iter.next(), Some(&2));
        assert_eq!(v1_iter.next(), Some(&3));
        assert_eq!(v1_iter.next(), None);
    }

　　

如果需要iterator接管被遍历的集合的ownership并返回带有ownership的值，可以使用into_iter。

如果需要产生mutable reference，我们可以调用iter_mut。

因为Iterator是懒加载的，所以可以把多个映射结合在一起形成计算链，最后再调用Consuming Adaptor得到最终结果。

    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect()//这里map从v1.iter()生成了新的iterator

　　

    shoes.into_iter().filter(|s| s.size == shoe_size).collect()

　　

Consuming Adaptors

调用iterator的next()方法的函数被称为consuming adaptor

    #[test]
    fn iterator_sum() {
        let v1 = vec![1, 2, 3];

        let v1_iter = v1.iter();

        let total: i32 = v1_iter.sum();//sum是Consuming adaptor

        assert_eq!(total, 6);
    }

　　

Customed Iterator

只要为自己的struct实现Iterator trait即可

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

fn main() {}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

　

    #[test]
    fn using_other_iterator_trait_methods() {
        let sum: u32 = Counter::new()
            .zip(Counter::new().skip(1))//这里只会生成(1, 2), ...(4,5),这4对，(5, None)不会生成
            .map(|(a, b)| a * b)
            .filter(|x| x % 3 == 0)
            .sum();
        assert_eq!(18, sum);
    }

　　

用Iterator也可以读取std::env::args:

　

impl Config {
    pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
        args.next();//第一个参数是程序本身，不要

        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };

        let filename = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a file name"),
        };

        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

        Ok(Config {
            query,
            filename,
            case_sensitive,
        })
    }
}

　　

Loops vs. Iterators 性能比较

书中用for循环写了一个过滤文件语句找是否存在关键词的程序，又用iterator写了一版，关键代码分别是：

for循环

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut results = Vec::new();

    for line in contents.lines() {
        if line.contains(query) {
            results.push(line);
        }
    }

    results
}

　　

iterator:

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    contents
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

　　

用柯南道尔的福尔摩斯作为测试，二者性能差不多，甚至iterator更甚一筹。书中认为这是因为Iterator是zero-cost abstractions，即无代价的抽象。这些iterator实际编译的底端代码已经性能很优秀，所以不会付出更多的运行代价。而且使用iteration，在编译器已知循环次数很少的时候，还会自动启动unrolling，即直接生成重复性的代码，以节约loop控制时间。