Functions

Functions are declared using the fn keyword. Its arguments are type
annotated, just like variables, and, if the function returns a value, the
return type must be specified after an arrow ->.

The final expression in the function will be used as return value.
Alternatively, the return statement can be used to return a value earlier
from within the function, even from inside loops or ifs.

Let’s rewrite FizzBuzz using functions!

  1. // Unlike C/C++, there's no restriction on the order of function definitions
  2. fn main() {
  3.     // We can use this function here, and define it somewhere later
  4.     fizzbuzz_to(100);
  5. }
  7. // Function that returns a boolean value
  8. fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
  9.     // Corner case, early return
  10.     if rhs == 0 {
  11.         return false;
  12.     }
  14.     // This is an expression, the `return` keyword is not necessary here
  15.     lhs % rhs == 0
  16. }
  18. // Functions that "don't" return a value, actually return the unit type `()`
  19. fn fizzbuzz(n: u32) -> () {
  20.     if is_divisible_by(n, 15) {
  21.         println!("fizzbuzz");
  22.     } else if is_divisible_by(n, 3) {
  23.         println!("fizz");
  24.     } else if is_divisible_by(n, 5) {
  25.         println!("buzz");
  26.     } else {
  27.         println!("{}", n);
  28.     }
  29. }
  31. // When a function returns `()`, the return type can be omitted from the
  32. // signature
  33. fn fizzbuzz_to(n: u32) {
  34.     for n in 1..n + 1 {
  35.         fizzbuzz(n);
  36.     }
  37. }