1. fn main() {
  2.     println!("Hello, world!");
  4.     another_function();
  5. }
  7. fn another_function() {
  8.     println!("Another function.");
  9. }
因为程序中已定义 another_function 函数，所以可以在 main 函数中调用它。注意，源 another_function 定义在 main 函数 之后；也可以定义在之前。Rust 不关心函数定义于何处，只要定义了就行。

函数参数

函数也可以被定义为拥有 参数（parameters），参数是特殊变量，是函数签名的一部分。当函数拥有参数（形参）时，可以为这些参数提供具体的值（实参）。技术上讲，这些具体值被称为参数（arguments），一般不做区分。 
  1. fn main() {
  2.     another_function(5);
  3. }
  5. fn another_function(x: i32) {
  6.     println!("The value of x is: {}", x);
  7. }
  1. fn main() {
  2.     another_function(5, 6);
  3. }
  5. fn another_function(x: i32, y: i32) {
  6.     println!("The value of x is: {}", x);
  7.     println!("The value of y is: {}", y);
  8. }
在函数签名中，必须 声明每个参数的类型。

包含语句和表达式的函数体

语句（Statements）是执行一些操作但不返回值的指令。表达式（Expressions）计算并产生一个值。

表达式加上分号就是语句

  1. fn main() {
  2.     let x = (let y = 6);
  3. }
  5. // 报错 let y = 6语句并不返回值   不同于C和Ruby
  1. fn main() {
  2.     let x = 5;
  4.     let y = {
  5.         let x = 3;
  6.         x + 1
  7.     };
  9.     println!("The value of y is: {}", y);
  10. }
这个表达式： 
  1. {
  2.     let x = 3;
  3.     x + 1
  4. }
是一个代码块，它的值是 4。这个值作为 let 语句的一部分被绑定到 y 上。注意结尾没有分号的那一行 x+1，与你见过的大部分代码行不同。表达式的结尾没有分号。如果在表达式的结尾加上分号，它就变成了语句，而语句不会返回值。

具有返回值的函数

函数可以向调用它的代码返回值。我们并不对返回值命名，但要在箭头（->）后声明它的类型。 在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。使用 return 关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式。 
  1. fn five() -> i32 {
  2.     5
  3. }
  5. fn main() {
  6.     let x = five();
  8.     println!("The value of x is: {}", x);
  9. }
  11. // 返回5
  1. fn main() {
  2.     let x = plus_one(5);
  4.     println!("The value of x is: {}", x);
  5. }
  7. fn plus_one(x: i32) -> i32 {
  8.     x + 1
  9. }
  10. // 返回6
  1. fn main() {
  2.     let x = plus_one(5);
  4.     println!("The value of x is: {}", x);
  5. }
  7. fn plus_one(x: i32) -> i32 {
  8.     x + 1;
  9. }
  11. // 报错 语句不返回值