函数
函数（function）使用
fn关键字来声明。函数的参数需要标注类型，就和变量一样，如果函数返回一个值，返回类型必须在箭头->之后指定。
函数最后的表达式将作为返回值。也可以在函数内使用 return 语句来提前返一个值。
以经典的两数之和为例（这里不考虑使用哈希表方式）：
// 指定参数类型、返回值类型
pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
// 循环数组
for i in 0..nums.len() {
for j in i+1..nums.len() {
if (nums[i] + nums[j] == target) {
// 可以使用 return 提前返回
return vec![i as i32, j as i32];
}
}
}
// 走到结尾了也没匹配上（虽然题目保证一定有匹配值），需要保证返回值的类型
vec![0, 0]
}
方法
方法（method）是依附于对象的函数。这些方法通过关键字
self来访问对象中的数据和其他。方法在impl代码块中定义。
方法即是放在对象里的函数，对象里的函数就是方法，方法使用 . 访问，下面是一个简单的使用示例：
#![allow(dead_code)]
struct Flower {
color: String,
smell: String,
}
impl Flower {
fn new(color: &str, smell: &str) -> Flower { // 构造方法
Flower { color: color.to_string(), smell: smell.to_string() }
}
// `&self` 是 `self: &Self` 的语法糖（sugar），self指向自己。
fn say(&self) { // 方法
println!(
"{}",
format!("I love {} Rose, it smell {}.", self.color, self.smell)
);
}
}
fn main() {
let rose = Flower::new("red", "good"); // 使用构造函数
rose.say(); // 调用 say 方法
}
闭包
Rust 中，函数和方法使用方式和其它语言类似，基本没什么特殊的地方。但是Rust中有一种特殊的函数，叫做闭包，如下一个将变量加一的闭包：
fn main() {
let num = 1;
// 闭包 等同于 fn add_one(i: i32) -> i32 { i + 1 }
let add_one = |i| i + 1; // |i| { i + 1 } 括号可以省略
println!("{}", add_one(num)); // 2
}
Rust 中的闭包（
closure），也叫做lambda表达式或者lambda，是一类能够捕获周围作用域中变量的函数。
闭包于普通函数而言，有几个特殊的地方：
- 语法简单，只需要指定变量名，而输入和返回类型两者都可以自动推导（可以主动指定类型）。
- 写法简单，声明时使用 || 替代 () 将输入参数括起来。
- 可省略大括号，大括号在只有单个表达式时是可选的。
- 捕获变量，有能力捕获外部环境的变量。
捕获变量
在普通函数里，传入的参数类型需要指定类型，如果只使用引用需要指定引用类型，而闭包可以灵活地判断使用引用还是变量本身。
- 通过引用
&T捕获变量
fn main() {
let letter = "A";
let print = || println!("letter is {}", letter);
print();
// `color` 可再次被不可变借用，因为闭包只持有一个指向 `color` 的不可变引用。
let _reborrow = &letter;
print();
// 在最后使用 `print` 之后，移动或重新借用都是允许的。
let _color_moved = letter;
}
- 通过可变引用
&mut T捕获变量
fn main() {
let mut count = 0;
let mut add_one = || {
count += 1;
println!("`count`: {}", count);
};
// 使用可变借用调用闭包
add_one();
// 因为之后调用闭包，所以仍然可变借用 `count`
// let _reborrow = &count; 试图重新借用将导致错误
add_one();
// 闭包不再借用 `&mut count`，因此可以正确地重新借用
let _count_reborrowed = &mut count;
}
- 通过值
T捕获变量（拿到了变量的所有权而非借用）
use std::mem;
fn main() {
// 内置 Box 类型将数据存储在堆上
let movable = Box::new(3);
// `mem::drop` 释放资源
let consume = || {
println!("`movable`: {:?}", movable);
mem::drop(movable);
};
// `consume` 消耗了该变量，所以该闭包只能调用一次。
consume();
}
闭包优先通过引用来捕获变量，并且仅在需要时使用其他方式。
闭包本质上很灵活，能做功能要求的事情，使闭包在没有类型标注的情况下运行。这使得捕获（capture）能够灵活地适应用例，既可移动（move），又可借用（borrow）。
在竖线 | 之前使用 move 关键词会强制闭包取得被捕获变量的所有权：
fn main() {
let nums = vec![1, 2, 3];
let contains = move |num| nums.contains(num);
println!("{}", contains(&1));
println!("{}", contains(&4));
// 报错， 借用检查不允许在变量被移动走之后继续使用它。
println!("There're {} elements in vec", nums.len());
}
将闭包作为函数参数
可以将闭包作为函数的参数，需要使用 where 关键词指定闭包的类型。一共有三种闭包类型：
-
Fn：表示捕获方式为通过引用（&T）的闭包。 -
FnMut：表示捕获方式为通过可变引用（&mut T）的闭包。 -
FnOnce：表示捕获方式为通过值（T）的闭包。
// 使用无参数和返回值的闭包作为 输入参数
fn read<F>(f: F) where F: FnOnce() {
f();
}
// 有参数和返回值的闭包作为 输入参数
fn write<F>(f: F) -> i32 where F: Fn(i32) -> i32 {
f(3)
}
注意，指定输入参数中闭包的类型时，闭包可能采取 &T，&mut T 或 T 中的一种捕获方式，编译器最终是根据所捕获变量在闭包里的使用情况决定捕获方式。所以，需要给到足够多的“权限”，即闭包捕获的是引用类型可以指定Fn，FnMut 或 FnOnce，但是如果捕获的是值，则需要指定 FnOnce。
fn read<F>(f: F) where F: Fn() {
f();
}
fn main() {
let name = "read";
let diary = || {
println!("{}.", name);
};
read(diary);
}
扩展：既然闭包可以作为函数的输入参数，那么普通函数也是可以的：
fn run_fn<F : Fn()>(f: F) { // 也是 Fn FnMut fnOnce 三种泛型类型
f();
}
fn print_hello() {
println!("Hello!");
}
fn main() {
run_fn(print_hello);
}
将闭包作为返回值
目前 Rust 只支持返回具体（非泛型）的类型。按照定义，匿名的闭包的类型是未知的，所以只有使用impl Trait才能返回一个闭包。
除此之外，还必须使用 move 关键字，它表明所有的捕获都是通过值进行的。这是必须的，因为在函数退出时，任何通过引用的捕获都被丢弃，在闭包中留下无效的引用。
fn create_fn() -> impl Fn() {
let text = "Fn".to_owned();
move || println!("This is a: {}", text)
}
fn create_fnmut() -> impl FnMut() {
let text = "FnMut".to_owned();
move || println!("This is a: {}", text)
}
fn create_fnonce() -> impl FnOnce() {
let text = "FnOnce".to_owned();
move || println!("This is a: {}", text)
}
fn main() {
let fn_plain = create_fn();
let mut fn_mut = create_fnmut();
let fn_once = create_fnonce();
fn_plain();
fn_mut();
fn_once();
}
高阶函数
高阶函数（Higher Order Function, HOF），指那些输入一个或多个函数，并且/或者产生一个更有用的函数的函数。
Rust 同时支持链式调用，结合高阶函数，可实现函数式的代码：
fn is_odd(n: u32) -> bool {
n % 2 == 1
}
fn main() {
let upper = 1000;
let sum_of_squared_odd_numbers: u32 =
(0..).map(|n| n * n) // 所有自然数取平方
.take_while(|&n| n < upper) // 取小于上限的
.filter(|&n| is_odd(n)) // 取奇数
.fold(0, |sum, i| sum + i); // 最后加起来
}
发散函数
发散函数（diverging function）无返回值。 使用
!标记，这是一个空类型。
The ! type, also called “never”.
This is a nightly-only experimental API.
和所有其他类型相反，这个类型无法实例化，因为此类型可能具有的所有可能值的集合为空。 它与 () 类型不同，后者只有一个可能的值。
虽然这看起来像是一个抽象的概念，但实际上这非常有用且方便。这种类型的主要优点是它可以被转换为任何其他类型，从而可以在需要精确类型的地方使用，例如在 match 匹配分支。 这也是永远循环（如 loop {}）的函数（如网络服务器）或终止进程的函数（如 exit()）的返回类型。
Tips
- 方法里，
&self是self: &Self的语法糖，self指向自己，类似于 JS 中的this关键词。