Functions & Expressions

Rust is expression-oriented: most constructs evaluate to a value. Functions, blocks, if, and match are expressions. Statements (let, ;-terminated lines) perform actions without producing outer values.

Recipe

fn square(n: i32) -> i32 {
    n * n
}
 
fn max(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}
 
fn main() {
    let result = {
        let x = 4;
        square(x) + 1
    };
    println!("{result}");
}

When to reach for this: Structuring logic into small, composable functions and using blocks to scope intermediate values.

Working Example

fn classify(score: u32) -> &'static str {
    match score {
        0..=49 => "fail",
        50..=79 => "pass",
        _ => "honors",
    }
}
 
fn report(scores: &[u32]) -> String {
    let mut lines = String::new();
    for (i, &s) in scores.iter().enumerate() {
        let label = classify(s);
        lines.push_str(&format!("student {}: {label}\n", i + 1));
    }
    lines
}
 
fn main() {
    println!("{}", report(&[88, 42, 65]));
}

What this demonstrates:

• match ranges as an expression returning &str
• Block expression in report building a String
• Slice parameter &[u32] accepts arrays and Vec
• Functions compose without classes or methods (methods come later)

Deep Dive

How It Works

• Function signatures require parameter types; return type after ->
• The function body is a block expression
• return expr; exits early; trailing expression omits return
• A semicolon after the last expression returns () instead of the value

Statements vs Expressions

let x = 5;           // statement
5 + 1                // expression, evaluates to 6
{ let y = 3; y + 1 } // block expression -> 4

Diverging Functions

fn die(msg: &str) -> ! {
    panic!("{msg}");
}

Return type ! means the function never returns (panic, loop, exit).

Closures Preview

let add_one = |x| x + 1;
let doubled: Vec<_> = [1, 2, 3].iter().map(|n| n * 2).collect();

Closures capture variables from their environment. Full coverage is in the Closures section.

Gotchas

• Semicolon on the last line - fn id(x: i32) -> i32 { x; } returns () and fails to compile. Fix: Remove the trailing ;.
• Mismatched if arm types - if cond { 1 } else { "two" } errors. Fix: Return the same type from all arms or use explicit coercion.
• Returning references to locals - fn bad() -> &str { let s = String::from("x"); &s } fails borrow check. Fix: Return owned String or take input by reference.
• Shadowing parameter names - Legal but confusing. Fix: Use distinct names inside the body.
• Overusing return - Scattered return hides the natural expression flow. Fix: Use early return only for guards; otherwise use a final expression.

Alternatives

FAQs

Related

• Control Flow - loops and labeled blocks
• Rust Basics - first functions tour
• Closures Basics - anonymous functions
• Traits Basics - behavior as traits

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.