8.2 Defining and Calling Functions

Rust does not require forward declarations: you can call a function before it is defined in the same file. This design supports a top-down approach, where high-level logic appears at the top of the file and lower-level helper functions are placed below.

8.2.1 Basic Function Definition

Functions in Rust begin with the fn keyword, followed by a name, parentheses containing any parameters, optionally -> and a return type, and then a body enclosed in braces {}:

fn function_name(param1: Type1, param2: Type2) -> ReturnType {
    // function body
}
  • Parameters: Each parameter has a name and a type (param: Type).
  • Return Type: If omitted, the function returns the unit type (), similar to void in C.
  • No Separate Declarations: The compiler reads the entire module at once, so you can define functions in any order without forward declarations.

Example

fn main() {
    let result = add(5, 3);
    println!("Result: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Here, add is called before it appears in the file. Rust allows this seamlessly, removing the need for separate prototypes as in C.

Comparison with C

#include <stdio.h>

int add(int a, int b); // prototype required if definition appears later

int main() {
    int result = add(5, 3);
    printf("Result: %d\n", result);
    return 0;
}

int add(int a, int b) {
    return a + b;
}

In C, a forward declaration (prototype) is required if you want to call a function before its definition.

8.2.2 Calling Functions

To call a function, write its name followed by parentheses. If it has parameters, pass them in the correct order:

fn main() {
    greet("Alice", 30);
}

fn greet(name: &str, age: u8) {
    println!("Hello, {}! You are {} years old.", name, age);
}
  • Parentheses: Always required, even if the function takes no parameters.
  • Argument Order: Must match the function’s parameter list exactly.

8.2.3 Ignoring a Function’s Return Value

If you call a function that returns a value but do not capture or use it, you effectively discard that value:

fn returns_number() -> i32 {
    42
}

fn main() {
    returns_number(); // Return value is ignored
}

  • Rust silently allows discarding most values.

  • If the function is annotated with #[must_use] (common for Result<T, E>), the compiler may issue a warning if you ignore it.

  • If you truly want to discard such a return value, you can do:

    fn main() {
    let _ = returns_number(); // or
    // _ = returns_number();
}

Pay attention to warnings about ignored return values to avoid subtle bugs, especially when ignoring Result could mean missing potential errors.