Returning values - Rust for C-Programmers

8.4 Functions Returning Values

Functions can return nearly any Rust type, including compound types, references, and mutable values.

8.4.1 Defining a Return Type

When your function should return a value, specify the type after ->:

fn get_five() -> i32 {
    5
}

8.4.2 The `return` Keyword and Implicit Returns

Rust supports both explicit and implicit returns:

Using `return`

#![allow(unused)]
fn main() {
fn square(x: i32) -> i32 {
    return x * x;
}
}

Using return can be helpful for early returns (e.g., in error cases).

Implicit Return

In Rust, the last expression in the function body—if it ends without a semicolon—automatically becomes the return value:

#![allow(unused)]
fn main() {
fn square(x: i32) -> i32 {
    x * x  // last expression, no semicolon
}
}

Adding a semicolon turns the expression into a statement, producing no return value.

Comparison with C

In C, you must always use return value; to return a value.

8.4.3 Returning References (Including `&mut`)

Along with returning owned values (like String or i32), Rust lets you return references (including mutable ones). For example:

fn first_element(slice: &mut [i32]) -> &mut i32 {
    // Returns a mutable reference to the first element in the slice
    &mut slice[0]
}

fn main() {
    let mut data = [10, 20, 30];
    let first = first_element(&mut data);
    *first = 999;
    println!("{:?}", data); // [999, 20, 30]
}

Key considerations:

Lifetime Validity: The referenced data must remain valid for as long as the reference is used. Rust enforces this at compile time.
No References to Local Temporaries: You cannot return a reference to a local variable created inside the function, because it goes out of scope when the function ends.
```
fn create_reference() -> &mut i32 {
    let mut x = 10;
    &mut x // ERROR: x does not live long enough
}
```
Returning mutable references is valid when the data comes from outside the function (as a parameter) and remains alive after the function returns.

By managing lifetimes carefully, Rust prevents returning invalid references—eliminating the dangling-pointer issues common in lower-level languages.

Rust for C-Programmers