Expressions and functions

Everything is worth something, until you add a semicolon

In “Variables, functions and control flow” you already called a function, boost(), without naming why its last line had no ;. Here we formalize that: what an expression is, what a statement is, and why that difference decides whether your function compiles at all.

Rust builds almost everything out of expressions: a {} block, an if, a function call — all of them produce a value. A statement, on the other hand, produces nothing useful. Knowing which of the two you are looking at is the foundation for reading — and writing — any Rust function with confidence.

You will go through four stations: functions and calls, typed parameters, expressions versus statements, and the two ways to return a value.

INPUT · call6 arrives as n
BODY · squarefinal expression, no ;
OUTPUT · returnreturns to the call site

01 / 04FN · CALL · RESULT

fn declares a function; calling it runs its body

fn names a block of code so you can reuse it. Defining a function does not run it: only a call does. When you write square(6), Rust jumps into the body of square, substitutes n with 6, runs the instructions, and comes back with the result right at the call site.

A function does not run when defined, only when called.

lib.rsCompiles↗

/// Squares a number. The final expression, with no semicolon, is the
/// return value.
#[must_use]
pub fn square(n: i32) -> i32 {
    n * n
}

// Playground entry point for this example.
fn main() {
    println!("squared: {}", square(6));
}

Result

Parameters are typed and follow an order

A function can take several parameters, and each one declares its own type. power takes base: i32 and exponent: u32; order matters, because the compiler compares each argument against the parameter at that exact position.

Parameter types, together with the return type, form the function’s signature: a contract the compiler checks at every call, not only when the function is defined.

lib.rsCompiles↗

/// Raises `base` to `exponent`. Each parameter carries its own type;
/// argument order must match the signature.
#[must_use]
pub fn power(base: i32, exponent: u32) -> i32 {
    base.pow(exponent)
}

// Playground entry point for this example.
fn main() {
    println!("power: {}", power(2, 10));
}

Result

; turns an expression into a statement

x + 1 is an expression: it produces a value. Add a ; and it becomes a statement, which produces no useful value — it is worth (), the unit type. If that is the last line of a function promising to return i32, the compiler expected i32 and found ().

lib.rsDoes not compile↗

fn plus_one(x: i32) -> i32 {
    x + 1; // ERROR: el `;` convierte la expresión en sentencia
}

fn main() {
    println!("{}", plus_one(5));
}

Result

The compiler says (E0308)

mismatched types. The function promises i32, but the ; turns the last line into a statement worth ().

error[E0308]: mismatched types
--> src/main.rs:2:5
|
1 | fn plus_one(x: i32) -> i32 {
|                        --- expected `i32` because of return type
2 |     x + 1;
|     ^^^^^^- help: remove this semicolon to return this value
|     |
|     expected `i32`, found `()`

The fix is almost always exactly that: remove the ; from the final expression.

return exits early; the final expression exits at the end

A function’s final expression is its implicit return value. But sometimes you want to exit before reaching the end, and that is what return is for. In safe_divide, if b is zero, return 0 cuts execution right there; otherwise control keeps going until a / b, the final expression, which is returned with no need to write return.

lib.rsCompiles↗

/// Returns early with `return` when dividing by zero; otherwise the tail
/// expression is the implicit return value.
#[must_use]
pub fn safe_divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        return 0;
    }

    a / b
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", safe_divide(10, 2), safe_divide(10, 0));
}

Result

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Objective

Complete fibonacci so it returns the n-th term of the sequence (0-indexed: fibonacci(0) == 0).

Implement

Replace `todo!` with a `for` loop that updates two variables each turn.

Use two mutable variables that each advance one position per loop turn, and return the first one when it finishes.

/// Returns the n-th Fibonacci number (0-indexed: fibonacci(0) == 0).
pub fn fibonacci(n: u32) -> u64 {
    todo!("iterate n times, swapping a and b to compute the n-th Fibonacci number")
}

Check

Run the visible cases and use the diagnostic to correct the code.

Visible tests

produces the correct first terms and the correct tenth term

Compiler—

Modify the code before running the tests.

Help

View progressive hints or compare with the solution.

Commented solutionSolution↗

/// Returns the n-th Fibonacci number (0-indexed: fibonacci(0) == 0).
#[must_use]
pub fn fibonacci(n: u32) -> u64 {
    let (mut a, mut b) = (0u64, 1u64);

    for _ in 0..n {
        let next = a + b;
        a = b;
        b = next;
    }

    a
}

// Playground entry point for this example.
fn main() {
    println!("{}", fibonacci(10));
}

Result

Summary

fn declares a function; calling it runs its body, defining it does not.
Each parameter has its own type; together with the return type they form the function’s signature.
An expression produces a value; one extra ; turns it into a statement worth ().
An E0308 error with expected T, found () almost always means a stray ; on the final expression.
A function’s final expression is its implicit return; return is for early exits.
The unit type () takes up no memory: it is the default value when a function returns nothing useful.

Sources

The Rust Programming Languagech03-03 · Klabnik, Nichols, Krycho y la comunidad de Rust
Comprehensive Rustvariable_bindings/functions · Geisler y colaboradores (Google)
D3capitulo-3
Rust by Examplefn

Everything is worth something, until you add a semicolon

Calculate the n-th Fibonacci number iteratively.

Implement

Calculate Fibonacci iteratively

Check

Help

Summary

Sources