Functions

A Rust version of the famous FizzBuzz interview question:

  1. fn main() {
  2.     fizzbuzz_to(20);   // Defined below, no forward declaration needed
  3. }
  5. fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
  6.     if rhs == 0 {
  7.         return false;  // Corner case, early return
  8.     }
  9.     lhs % rhs == 0     // The last expression in a block is the return value
  10. }
  12. fn fizzbuzz(n: u32) -> () {  // No return value means returning the unit type `()`
  13.     match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {
  14.         (true,  true)  => println!("fizzbuzz"),
  15.         (true,  false) => println!("fizz"),
  16.         (false, true)  => println!("buzz"),
  17.         (false, false) => println!("{n}"),
  18.     }
  19. }
  21. fn fizzbuzz_to(n: u32) {  // `-> ()` is normally omitted
  22.     for i in 1..=n {
  23.         fizzbuzz(i);
  24.     }
  25. }

  • We refer in main to a function written below. Neither forward declarations nor headers are necessary.

  • Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.

  • The last expression in a function body (or any block) becomes the return value. Simply omit the ; at the end of the expression.

  • Some functions have no return value, and return the ‘unit type’, (). The compiler will infer this if the -> () return type is omitted.

  • The range expression in the for loop in fizzbuzz_to() contains =n, which causes it to include the upper bound.

  • The match expression in fizzbuzz() is doing a lot of work. It is expanded below to show what is happening.

    (Type annotations added for clarity, but they can be elided.)

    let by_3: bool = is_divisible_by(n, 3); let by_5: bool = is_divisible_by(n, 5); let by_35: (bool, bool) = (by_3, by_5); match by_35 { // ...