1. #[derive(Debug)]
  2. struct Shoe {
  3.     size: u32,
  4.     style: String,
  5. }
  7. fn find_suitable(data: &Vec<Shoe>, test_fn: fn(&Shoe) -> bool) -> Vec<&Shoe> {
  8.     let mut res= vec![];
  9.     for s in data.iter() {
  10.         if test_fn(s) {
  11.             res.push(s);
  12.         }
  13.     }
  14.     res
  15. }
  17. fn shoes_in_my_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
  18.     shoes.into_iter()
  19.         .filter(move |s| s.size == shoe_size)
  20.         .collect()
  21. }
  24. fn main() {
  25.   let shoes = vec![
  26.     Shoe {size: 10, style: String::from("aaa")},
  27.     Shoe {size: 13, style: String::from("bbb")},
  28.   ]; 
  29.   let res = find_suitable(&shoes, |s| {s.size > 5});
  30.   println!("res {:?}", res);
  31. }

capture environment

clousure 的作用可以capture enclose函数的变量，有几种capture的方式

move

将变量move到闭包函数中，对应的是 FnOnce

  1. fn move_capture() {
  2.     let x = vec![1,2,3];
  3.     let equal_to_x = move |z| x == z;
  4.     // println!("{:?}", x); this won't compile as x has been moved
  5.     let y = vec![1,2,3];
  6.     assert_eq!(equal_to_x(y), true);
  7. }

borrow mut

&mut || {} 表示mutable borrow 了 clousure中用到的变量，x， 所以当mutate_x 执行后，任然可以使用x，因为x是 被borrow进了clousure中。

  1. fn mutate_capture() -> Vec<i32> {
  2.     let mut x = vec![1, 2, 3];
  3.     let mutate_x = &mut |z| x.iter_mut().for_each(|y| *y = *y + z);
  4.     mutate_x(1);
  5.     println!("{:?}", x);
  6.     x
  7. }

clousure as return type

  1. fn create_fn() -> impl Fn() {
  2.     let text = "Fn".to_string();
  3.     move || println!("this is a {}", text);
  4. }

必须使用 move 关键字，表明clousure补货的变量都是by value，因为当函数结束后，text将会被drop