• 函数与方法
    • 函数
    • 匿名函数
    • 高阶函数
    • 方法

    函数与方法

    函数

    要声明一个函数，需要使用关键字fn，后面跟上函数名，比如

    1. fn add_one(x: i32) -> i32 {
    2.     x + 1
    3. }

    其中函数参数的类型不能省略，可以有多个参数，但是最多只能返回一个值，
    提前返回使用return关键字。Rust编译器会对未使用的函数提出警告，
    可以使用属性#[allow(dead_code)]禁用无效代码检查。

    Rust有一个特殊特性适用于发散函数 (diverging function)，它不返回：

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

    其中panic!是一个宏，使当前执行线程崩溃并打印给定信息。返回类型!可用作任何类型：

    1. let x: i32 = diverges();
    2. let y: String = diverges();

    匿名函数

    Rust使用闭包 (closure) 来创建匿名函数：

    1. let num = 5;
    2. let plus_num = |x: i32| x + num;

    其中闭包plus_num借用了它作用域中的let绑定num。如果要让闭包获得所有权，
    可以使用move关键字：

    1. let mut num = 5;
    3. {
    4.     let mut add_num = move |x: i32| num += x;   // 闭包通过move获取了num的所有权
    6.     add_num(5);
    7. }
    9. // 下面的num在被move之后还能继续使用是因为其实现了Copy特性
    10. // 具体可见所有权(Owership)章节
    11. assert_eq!(5, num);

    高阶函数

    Rust 还支持高阶函数 (high order function)，允许把闭包作为参数来生成新的函数：

    1. fn add_one(x: i32) -> i32 { x + 1 }
    3. fn apply<F>(f: F, y: i32) -> i32
    4.     where F: Fn(i32) -> i32
    5. {
    6.     f(y) * y
    7. }
    9. fn factory(x: i32) -> Box<Fn(i32) -> i32> {
    10.     Box::new(move |y| x + y)
    11. }
    13. fn main() {
    14.     let transform: fn(i32) -> i32 = add_one;
    15.     let f0 = add_one(2i32) * 2;
    16.     let f1 = apply(add_one, 2);
    17.     let f2 = apply(transform, 2);
    18.     println!("{}, {}, {}", f0, f1, f2);
    20.     let closure = |x: i32| x + 1;
    21.     let c0 = closure(2i32) * 2;
    22.     let c1 = apply(closure, 2);
    23.     let c2 = apply(|x| x + 1, 2);
    24.     println!("{}, {}, {}", c0, c1, c2);
    26.     let box_fn = factory(1i32);
    27.     let b0 = box_fn(2i32) * 2;
    28.     let b1 = (*box_fn)(2i32) * 2;
    29.     let b2 = (&box_fn)(2i32) * 2;
    30.     println!("{}, {}, {}", b0, b1, b2);
    32.     let add_num = &(*box_fn);
    33.     let translate: &Fn(i32) -> i32 = add_num;
    34.     let z0 = add_num(2i32) * 2;
    35.     let z1 = apply(add_num, 2);
    36.     let z2 = apply(translate, 2);
    37.     println!("{}, {}, {}", z0, z1, z2);
    38. }

    方法

    Rust通过impl关键字在struct、enum或者trait对象上实现方法调用语法 (method call syntax)。
    关联函数 (associated function) 的第一个参数通常为self参数，有3种变体：

    • self，允许实现者移动和修改对象，对应的闭包特性为FnOnce。
    • &self，既不允许实现者移动对象也不允许修改，对应的闭包特性为Fn。
    • &mut self，允许实现者修改对象但不允许移动，对应的闭包特性为FnMut。

    不含self参数的关联函数称为静态方法 (static method)。

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn new(x: f64, y: f64, radius: f64) -> Circle {
    9.         Circle {
    10.             x: x,
    11.             y: y,
    12.             radius: radius,
    13.         }
    14.     }
    16.     fn area(&self) -> f64 {
    17.         std::f64::consts::PI * (self.radius * self.radius)
    18.     }
    19. }
    21. fn main() {
    22.     let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
    23.     println!("{}", c.area());
    25.     // use associated function and method chaining
    26.     println!("{}", Circle::new(0.0, 0.0, 2.0).area());
    27. }