深入了解Rust中函数与闭包的使用

fn main() {
    let closure = |n: u32| -> u32 {
        n * 2
    };
    println!("n * 2 = {}", closure(12));
    // n * 2 = 24
}

// 普通函数定义
fn func1(a: u32, b: u32) -> String {
    // 函数体
}
/* 如果换成闭包的话，那么等价于
let func1 = |a: u32, b: u32| -> String {
    // 函数体
}
*/

fn main() {
    let closure1 = |n: u32| -> u32 {
        n * 2
    };

    fn closure2(n: u32) -> u32 {
        n * 2
    }

    println!("n * 2 = {}", closure1(12));
    println!("n * 2 = {}", closure2(12));
    /*
    n * 2 = 24
    n * 2 = 24
    */
}

// 导入线程模块
use std::thread;

fn main() {
    let s = String::from("hello world");
    // 必须在 || 的前面加上 move
    // 它的含义就是将值从主线程移动到子线程
    let closure1 = move || {
        println!("{}", s);
    };
    // 开启一个子线程
    thread::spawn(closure1).join();
    /*
    hello world
    */
}

// calc 接收三个参数，返回一个 i32
// 参数一：接收两个 i32 返回一个 i32 的函数
// 参数二 和 参数三均是一个 i32
fn calc(method: fn(i32, i32) -> i32,
        a: i32, b: i32) -> i32 {
    method(a, b)
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}
fn main() {
    println!("a + b = {}", calc(add, 12, 33));
    /*
    a + b = 45
    */

    // 也可以传递一个匿名函数，但它不能引用外层作用域的变量
    // 因为 calc 第一个参数接收的是函数，不是闭包
    let sub = |a: i32, b: i32| -> i32 {
        a - b
    };

    println!("a - b = {}", calc(sub, 12, 33));
    /*
    a - b = -21
    */
}

// 相当于给类型起了一个别名
type Method = fn(i32, i32) -> i32;

fn calc(method: Method,
        a: i32, b: i32) -> i32 {
    method(a, b)
}

type Method = fn(i32, i32) -> i32;

// 想要接收字符串的话
// 应该使用引用 &String 或切片 &str
// 当然我们前面说过，更推荐切片
fn calc(op: &str) -> Method {
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    
    let sub = |a: i32, b: i32| -> i32 { a - b };

    // 使用 if else 也是可以的
    match op {
        "add" => add,
        "sub" => sub,
        // 内置的宏，会抛出一个错误，表示方法没有实现
        _ => unimplemented!(),
    }  // 注意：此处不可以加分号，因为要作为表达式返回
}

fn main() {
    let (a, b) = (11, 33);
    println!("a + b = {}", calc("add")(a, b));
    println!("a - b = {}", calc("sub")(a, b));
    /*
    a + b = 44
    a - b = -22
    */
}

enum Result {
    Text(String),
    Func(fn() -> String),
}

fn index() -> String {
    String::from("欢迎来到古明地觉的编程教室")
}

fn login_required(username: &str, password: &str) -> Result {
    if !(username == "satori" && password == "123") {
        return Result::Text(String::from("请先登录"));
    } else {
        return Result::Func(index);
    }
}

fn main() {
    let res1 = login_required("xxx", "yyy");
    let res2 = login_required("satori", "123");
    // 如果后续还要使用 res1 和 res2，那么就使用引用
    // 也就是 [&res1, &res2]
    // 但这里我们不用了，所以是 [res1, res2]，此时会转移所有权
    for item in [res1, res2] {
        match item {
            Result::Text(error) => println!("{}", error),
            Result::Func(index) => println!("{}", index()),
        }
    }
    /*
    请先登录
    欢迎来到古明地觉的编程教室
    */
}

// 发散函数的返回值类型是一个感叹号
// 它表示这个函数执行时会报错
fn foo() -> ! {
    panic!("这个函数执行时会报错")
}

fn main() {
    // 调用发散函数时，可以将其结果赋值给任意类型的变量
    let res1: u32 = foo();
    let res2: f64 = foo();
}

// 发散函数的返回值类型是一个感叹号
// 它表示这个函数执行时会报错
fn foo() -> ! {
    panic!("这个函数执行时会报错");
}

// 不指定返回值，默认返回 ()
// 所以以下等价于 fn bar() -> () {}
// 但很明显 bar 函数是有返回值的，会返回空元组
fn bar() {

}