Functions in Rust can pass back a value to the code that calls them. The type of the returned value needs to be declared after an arrow (->) but it doesn't need a name. The final expression in the function's body is automatically returned unless the return keyword is used to specify a specific value or the function ends early.

For example:
```rust
// Way 1:
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

// Way 2:
fn add(a: i32, b: i32) -> i32 {
    a + b;
    // The value of the final expression in the function
    // body will be implicitly returned as the output
}

let result = add(3, 4);
println!("The result is: {}", result);
```

In this example, the function add takes two integers, \`a\` and \`b\`, as input and returns an integer, which is the sum of \`a\` and \`b\`. The function is called with the values \`3\` and \`4\` and the result is stored in the variable \`result\`. The final line then prints "The result is: 7".

Functions with Return Values - Rust Programming

Functions are commonly used in Rust code, with the main function being a key element and entry point for many programs. The fn keyword is used to create new functions.

Syntax:
```rust
fn function_name(parameter_name: parameter_type) -> return_type {
    // code block
}
```


For example:
```rust
fn add(a: i32, b: i32) -> i32 {
    a + b
}
```

University of Michigan - Ann Arbor

By default, variables in Rust are immutable, meaning their value cannot be changed once assigned. To allow a variable to be mutable, the keyword "mut" must be used when declaring the variable.

Immutable example:
```rust
let x = 5;
```
This declares a variable named "x" and assigns it the value of 5. The type of x is inferred by the compiler to be i32.

Mutable example:
```rust
let mut y = 10;
y = 20;
```
This declares a mutable variable "y" with an initial value of 10 and then changes the value to 20.

Learn Before

Related

Learn After