Functions, statements and expressions

Why functions?

A function is a named block of code that does one job. You write it once and call it many times, with different inputs. You already know main. Rust uses snake_case names and you can define functions in any order in the file.

fn main() {
    greet("Meena");
    let total = add(250, 120);
    println!("Total: {total}");
}

fn greet(name: &str) {
    println!("Namaste, {name}!");
}

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

Parameters always need types

Parameters are the inputs a function takes. In Rust you must write the type of every parameter, even when it seems obvious. This is a deliberate choice: the function's signature (its first line) then fully describes how to call it, and the compiler can check every call.

Statements and expressions

This idea is small but it explains much of Rust. A statement does something and gives back no value. let x = 5; is a statement. An expression is evaluated to a value. 5 + 6 is an expression, a call like add(1, 2) is an expression, and even a block in curly braces is an expression: its value is its last line, if that line has no semicolon.

let fee = {
    let base = 1000;
    let gst = base * 18 / 100;
    base + gst          // no semicolon: this is the block's value
};
println!("{fee}");      // 1180

Returning values

The return type is written after an arrow ->. The value of the last expression in the body is returned automatically. Use the return keyword only to leave early, for example inside an if.

fn discount(amount: u32) -> u32 {
    if amount < 500 {
        return 0;             // early exit
    }
    amount / 10               // the normal result
}

The famous semicolon mistake

fn square(n: i32) -> i32 {
    n * n;
}
// error[E0308]: mismatched types
//   expected `i32`, found `()`
// help: remove this semicolon to return this value

Read that message slowly: the function promised an i32, but the body ended with a statement, so it produced the unit type (). The compiler even tells you which semicolon to remove.

Functions that return nothing

If you leave out -> and a type, the function returns (), the unit type. That is what greet above does. A function can also never return at all, written -> !, but you will rarely write that yourself.

Common mistakes

• Forgetting parameter types: fn add(a, b) does not compile. Write fn add(a: i32, b: i32).
• A semicolon after the last expression of a function with a return type: remove it.
• Using return everywhere. It works, but idiomatic Rust uses the last expression and keeps return for early exits.
• Passing the wrong number type: add(5u8, 3) when add takes i32. Convert first or change the signature.