函数

  1. fn foo(a: i32) -> i32 { a }
  3. fn foo<A, B>(x: A, y: B) {}                           // generic function 
  5. fn foo<T>(x: T) where T: Debug {}                     // generic function 
  7. // Declares an extern fn, the ABI defaults to "C"
  8. extern fn new_i32() -> i32 { 0 }                      // Extern function
  10. // Declares an extern fn with "stdcall" ABI
  11. extern "stdcall" fn new_i32_stdcall() -> i32 { 0 }    // Extern function
  13. let fptr: extern "C" fn() -> i32 = new_i32;

函数也有一个类型！它们看起来像这样：

  1. fn foo(a: i32) -> i32 { a }
  3. let x: fn(i32) -> i32 = foo;

在这个例子中，x是一个“函数指针”，指向一个获取一个i32参数并返回一个i32值的函数。

函数不支持默认參數，要用其他的方式模拟此特性。其中一个是利用 Default trait

  1. use std::default::Default;
  3. #[derive(Debug)]
  4. pub struct Parameter {
  5.     a: u32,
  6.     b: u32,
  7.     c: u32,
  8. }
  10. // Set default values for Parameter struct
  11. impl Default for Parameter {
  12.     fn default() -> Self {
  13.         Parameter { a: 2, b: 4, c: 6}
  14.     }
  15. }
  17. fn some_calc(p: Parameter) -> u32 {
  18.     let (a, b, c) = (p.a, p.b, p.c);
  19.     a + b + c
  20. }
  22. fn main() {
  23.     // Set default values for p except c
  24.     let p = Parameter { c: 10, .. Parameter::default() };
  25.     println!("{}", some_calc(p));
  26. }

提早返回

Rust有一个关键字，return.

  1. fn foo(x: i32) -> i32 {
  2.     return x;
  4.     // we never run this code!
  5.     x + 1
  6. }

Diverging functions

Rust有些特殊的语法，这些函数并不返回：

  1. fn diverges() -> ! {
  2.     panic!("This function never returns!");
  3. }

panic!是一个宏，类似我们已经见过的println!()。与println!()不同的是，panic!()导致当前的执行线程崩溃并返回指定的信息。因为这个函数会崩溃，所以它不会返回，所以它拥有一个类型!，它代表“发散”。

如果你添加一个叫做diverges()的函数并运行，你将会得到一些像这样的输出：

  1. thread ‘<main>’ panicked at ‘This function never returns!’, hello.rs:2

如果你想要更多信息，你可以设定RUST_BACKTRACE环境变量来获取 backtrace ：

  1. $ RUST_BACKTRACE=1 ./diverges
  2. thread '<main>' panicked at 'This function never returns!', hello.rs:2
  3. stack backtrace:
  4.    1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r
  5.    2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w
  6.    3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw
  7.    4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650
  8.    5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa
  9.    6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa
  10.    7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231
  11.    8:     0x7f402773d1d8 - __rust_try
  12.    9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w
  13.   10:     0x7f4027738a19 - main
  14.   11:     0x7f402694ab44 - __libc_start_main
  15.   12:     0x7f40277386c8 - <unknown>
  16.   13:                0x0 - <unknown>

RUST_BACKTRACE也可以用于 Cargo 的run命令：

  1. $ RUST_BACKTRACE=1 cargo run
  2.      Running `target/debug/diverges`
  3. thread '<main>' panicked at 'This function never returns!', hello.rs:2
  4. stack backtrace:
  5.    1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r
  6.    2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w
  7.    3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw
  8.    4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650
  9.    5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa
  10.    6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa
  11.    7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231
  12.    8:     0x7f402773d1d8 - __rust_try
  13.    9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w
  14.   10:     0x7f4027738a19 - main
  15.   11:     0x7f402694ab44 - __libc_start_main
  16.   12:     0x7f40277386c8 - <unknown>
  17.   13:                0x0 - <unknown>

diverge函数可以被用作任何类型：

  1. fn diverges() -> ! {
  2.    panic!("This function never returns!");
  3. }
  4. let x: i32 = diverges();
  5. let x: String = diverges();

函数指针

我们也可以创建指向函数的变量绑定：

  1. fn plus_one(i: i32) -> i32 {
  2.     i + 1
  3. }
  5. // without type inference
  6. let f: fn(i32) -> i32 = plus_one;
  8. // with type inference
  9. let f = plus_one;

你可以用f来调用这个函数：

  1. # fn plus_one(i: i32) -> i32 { i + 1 }
  2. # let f = plus_one;
  3. let six = f(5);

高阶函数

高阶函数与普通函数的不同在于，它可以使用一个或多个函数作为参数，可以将函数作为返回值。rust的函数是first class type，所以支持高阶函数。而，由于rust是一个强类型的语言，如果要将函数作为参数或返回值，首先需要搞明白函数的类型。下面先说函数的类型，再说函数作为参数和返回值。

前面说过，关键字fn可以用来定义函数。除此以外，它还用来构造函数类型。与函数定义主要的不同是，构造函数类型不需要函数名、参数名和函数体。在Rust Reference中的描述如下：

The function type constructor fn forms new function types. A function type consists of a possibly-empty set of function-type modifiers (such as unsafe or extern), a sequence of input types and an output type.

  2. fn inc(n: i32) -> i32 {//函数定义
  3.   n + 1
  4. }
  6. type IncType = fn(i32) -> i32;//函数类型
  8. fn main() {
  9.   let func: IncType = inc;
  10.   println!("3 + 1 = {}", func(3));
  11. }

上例首先使用fn定义了inc函数，它有一个i32类型参数，返回i32类型的值。然后再用fn定义了一个函数类型，这个函数类型有i32类型的参数和i32类型的返回值，并用type关键字定义了它的别名IncType。在main函数中定义了一个变量func，其类型就为IncType，并赋值为inc，然后在pirntln宏中调用：func(3)。可以看到，inc函数的类型其实就是IncType。 

  1. fn main() {
  2.   let func: IncType = inc;
  3.   println!("3 + 1 = {}", func(3));
  4.   println!("3 + 1 = {}", inc(3));
  5. }
  7. type IncType = fn(i32) -> i32;
  9. fn inc(n: i32) -> i32 {
  10.   n + 1
  11. }
  1. 3 + 1 = 4
  2. 3 + 1 = 4

这说明，赋值时，inc函数的所有权并没有被转移到func变量上，而是更像不可变引用。在rust中，函数的所有权是不能转移的，我们给函数类型的变量赋值时，赋给的一般是函数的指针，所以rust中的函数类型，就像是C/C++中的函数指针，当然，rust的函数类型更安全。可见，rust的函数类型，其实应该是属于指针类型（Pointer Type）。rust的Pointer Type有两种，一种为引用（Reference&），另一种为原始指针（Raw pointer *），详细内容请看Rust Reference 8.18 Pointer Types。而rust的函数类型应是引用类型，因为它是安全的，而原始指针则是不安全的，要使用原始指针，必须使用unsafe关键字声明。

函数作参数

函数作为参数，其声明与普通参数一样

  1. fn main() {
  2.   println!("3 + 1 = {}", process(3, inc));
  3.   println!("3 - 1 = {}", process(3, dec));
  4. }
  6. fn inc(n: i32) -> i32 {
  7.   n + 1
  8. }
  10. fn dec(n: i32) -> i32 {
  11.   n - 1
  12. }
  14. fn process(n: i32, func: fn(i32) -> i32) -> i32 {
  15.   func(n)
  16. }

例子中，process就是一个高阶函数，它有两个参数，一个类型为i32的n，另一个类型为fn(i32)->i32的函数func，返回一个i32类型的参数；它在函数体内以n作为参数调用func函数，返回func函数的返回值。运行可以得到以下结果：

  1. 3 + 1 = 4
  2. 3 - 1 = 2

不过，这不是函数作为参数的唯一声明方法，使用泛型函数配合特质（trait）也是可以的，因为rust的函数都会实现一个trait:FnOnce、Fn或FnMut。将上例中的process函数定义换成以下形式是等价的：

  1. fn process<F>(n: i32, func: F) -> i32
  2.     where F: Fn(i32) -> i32 {
  3.     func(n)
  4. }

函数作为返回值

函数作为返回值，其生命与普通函数的返回值类型声明一样。看例子：

  1. fn main() {
  2.    let a = [1,2,3,4,5,6,7];
  3.    let mut b = Vec::<i32>::new();
  4.    for i in &a {
  5.        b.push(get_func(*i)(*i));
  6.    }
  7.    println!("{:?}", b);
  8. }
  10. fn get_func(n: i32) -> fn(i32) -> i32 {
  11.     fn inc(n: i32) -> i32 {
  12.         n + 1
  13.     }
  14.     fn dec(n: i32) -> i32 {
  15.         n - 1
  16.     }
  17.     if n % 2 == 0 {
  18.         inc
  19.     } else {
  20.         dec
  21.     }
  22. }

例子中的高阶函数为get_func，它接收一个i32类型的函数，返回一个类型为fn(i32) -> i32的函数，若传入的参数为偶数，返回inc，否则返回dec。这里需要注意的是，inc函数和dec函数都定义在get_func内。在函数内定义函数在很多其他语言中是不支持的，不过rust支持，这也是rust灵活和强大的一个体现。不过，在函数中定义的函数，不能包含函数中（环境中）的变量，若要包含，应该闭包。

返回多个值

rust的函数不支持多返回值,但是我们可以利用元组来返回多个值,配合rust的模式匹配,使用起来十分灵活。先看例子:

  1. fn main() {
  2.     let (p2,p3) = pow_2_3(789);
  3.     println!("pow 2 of 789 is {}.", p2);
  4.   println!("pow 3 of 789 is {}.", p3);
  5. }
  6. fn pow_2_3(n: i32) -> (i32, i32) {
  7.   (n*n, n*n*n)
  8. }

可以看到,上例中, pow_2_3函数接收一个i32类型的值,返回其二次方和三次方的值,这两个值包装在一个元组中返回。在 main函数中, let语句就可以使用模式匹配将函数返回的元组进行解构,将这两个返回值分别赋给 p2和p3,从而可以得到 789二次方的值和三次方的值。