Writing Functions

Working Code

Try running the code below in the Rust Playground!

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

fn main() {
    greet("DaleSchool");
    greet("Rust");
}

You can create functions with fn. Here we made a function called greet and called it twice from main.

Now let's look at a function that returns a value.

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

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

-> i32 means "this function returns a value of type i32." If you write a value on the last line of a function without a semicolon, that value gets returned.

Try It Yourself

Try adding a semicolon (;) after a + b in the code below. What error do you get?

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

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

Adding a semicolon causes an error; removing it makes the code work. Let's find out why below!

"Why?" — Expressions vs. Statements

In Rust, there's a distinction between expressions and statements.

• Expressions produce a value. Things like 3 + 5 and a + b are expressions.
• Statements don't produce a value. Adding a semicolon (;) turns something into a statement.

fn double(x: i32) -> i32 {
    x * 2   // No semicolon -> expression -> this value gets returned
}

fn main() {
    let result = double(7);
    println!("Double of 7: {result}");
}

If the last line of a function is an expression, its value is automatically returned. If you add a semicolon, it becomes a statement and returns nothing.

One more thing! Function parameters must always have explicit types. While let bindings can rely on type inference, function parameters cannot omit types.

fn is_even(number: i32) -> bool {
    number % 2 == 0
}

fn main() {
    println!("Is 4 even? {}", is_even(4));
    println!("Is 7 even? {}", is_even(7));
}

Deep Dive

fn check_age(age: i32) -> &'static str {
    if age < 0 {
        return "Age must be 0 or greater";
    }
    "Valid input"
}

fn main() {
    println!("{}", check_age(-1));
    println!("{}", check_age(20));
}

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

fn main() {
    println!("{}", add(1, 2));
}

error[E0308]: mismatched types
 --> src/main.rs:1:32
  |
1 | fn add(a: i32, b: i32) -> i32 {
  |    ---                     ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail expression
2 |     a + b;
  |          - help: remove this semicolon to return this value

fn mystery(x: i32) -> i32 {
    x * 3
}

fn half(x: i32) -> i32 {
    x / 2
}

fn main() {
    println!("{}", half(7));
}