Rust 闭包

闭包只是定义了代码，存储代码，并不是执行，切记。

Rust的闭包类型分为三种：
1.Fn
2.FnMut
3.FnOnce

不同之处：
1.它们的调用方法分别采用&self、&mut self和self，这意味着Fn对其捕获具有不可变的访问权限，FnMut获得可变的访问权限，FnOnce可以获得所有权。
2.Fn和FnMut类型的闭包可以执行多次，而FnOnce类型的闭包只能执行一次。

move关键字：
1.如果没有实现Copy，就是move语义，会发生移动。
2.如果实现Copy，则是copy语义，会发生拷贝。
值得注意的是move与闭包的类型没有关系

示例代码：
1.Fn

#[derive(Debug)]
struct Person {
    age: usize,
}

impl Person {
    fn print(self) {
        println!("{:?}", self);
    }

    fn print_ref(&self) {
        println!("{:?}", self);
    }

    fn print_mut_ref(&mut self) {
        println!("{:?}", self);
    }
}

fn call_fn<F: Fn()>(f: F) {
    f();
}

fn main() {
    let mut person = Person { age: 18 };

    call_fn(|| {
    	// Fn 可以获得不可变的访问权限
        person.print_ref();

        // Fn 不可以获得可变的访问权限
        // person.print_mut_ref();

        // Fn 不可以获得所有权
        // person.print();
    });
}

2.FnMut

#[derive(Debug)]
struct Person {
    age: usize,
}

impl Person {
    fn print(self) {
        println!("{:?}", self);
    }

    fn print_ref(&self) {
        println!("{:?}", self);
    }

    fn print_mut_ref(&mut self) {
        println!("{:?}", self);
    }
}

fn call_fn_mut<F: FnMut()>(mut f: F) {
    f();
}

fn main() {
    let mut person = Person { age: 18 };

    call_fn_mut(|| {
        // FnMut 可以获得不可变的访问权限
        person.print_ref();

        // FnMut 可以获得可变的访问权限
        person.print_mut_ref();

        // FnMut 不可以获得所有权
        // person.print();
    });
}

3.FnOnce

#[derive(Debug)]
struct Person {
    age: usize,
}

impl Person {
    fn print(self) {
        println!("{:?}", self);
    }

    fn print_ref(&self) {
        println!("{:?}", self);
    }

    fn print_mut_ref(&mut self) {
        println!("{:?}", self);
    }
}

fn call_fn_once<F: FnOnce()>(f: F) {
    f();
}

fn main() {
    let mut person = Person { age: 18 };

    call_fn_once(|| {
        // FnOnce 可以获得不可变的访问权限
        person.print_ref();

        // FnOnce 可以获得可变的访问权限
        person.print_mut_ref();

        // FnOnce 可以获得所有权
        person.print();
    });
}

4.Fn/FnMut/FnOnce

fn call_fn_once<F>(f: F, s: String)
    where F: FnOnce(String) -> String
{
    let res = f(s);
    println!("res: {}", res);
}

fn call_fn_mut<F>(mut f: F, s: String)
    where F: FnMut(String) -> String
{
    let res = f(s);
    println!("res: {}", res);
}

fn call_fn<F>(f: F, s: String)
    where F: Fn(String) -> String
{
    let res = f(s);
    println!("res: {}", res);
}

fn main() {
    let name1 = "upfly".to_owned();
    let mut name2 = name1.clone();
    let name3 = name1.clone();

    // Fn
    let c1 = |s: String| -> String {
        println!("name1: {}", name1);
        s
    };

    // FnMut
    let c2 = |s: String| -> String {
        name2.push_str("666");
        println!("name2: {}", name2);
        s
    };

    // FnOnce
    let c3 = move |s: String| -> String {
        println!("name3: {}", name3);
        let _name: String = name3;
        s
    };

    // FnOnce 可以接受 Fn/FnMut/FnOnce
    // Ok
    // call_fn_once(c1, "fn_once fn".to_owned());
    // Ok
    // call_fn_once(c2, "fn_once fn_mut".to_owned());
    // Ok
    // call_fn_once(c3, "fn_once fn_once".to_owned());

    // FnMut 只能接受 Fn 和 FnMut
    // Ok
    // call_fn_mut(c1, "fn_mut fn".to_owned());
    // Ok
    // call_fn_mut(c2, "fn_mut fn_mut".to_owned());
    // Err
    // call_fn_mut(c3, "fn_mut fn_once".to_owned());

    // Fn 只能接受 Fn
    // Ok
    // call_fn(c1, "fn fn".to_owned());
    // Err
    // call_fn(c2, "fn fn_mut".to_owned());
    // Err
    // call_fn(c3, "fn fn_once".to_owned());
}

5.move

#[derive(Debug, Clone, Copy)]
struct Person {
    age: usize,
}

fn call_fn<F: Fn()>(f: F) {
    f();
}

fn main() {
    let person = Person { age: 18 };

    call_fn(move || {
        println!("{:?}", person);
    });

    // 不实现 Copy，报错 value borrowed here after move
    println!("{:?}", person);
}