Functions | Functions and Modules Tutorial

Rust Functions

Functions are the building blocks of most programs. They encapsulate reusable blocks of code, making programs more organized, readable, and maintainable. Rust functions are powerful and flexible. Here's a breakdown:

1. Defining a Function

The basic syntax for defining a function in Rust is:

fn function_name(parameter1: Type1, parameter2: Type2) -> ReturnType {
    // Function body - code to be executed
    // ...
    return value; // Optional if the last expression is the return value
}

fn keyword: Indicates that you're defining a function.
function_name: The name of your function. Follows Rust's naming conventions (snake_case).
parameter1: Type1, parameter2: Type2: The function's parameters. Each parameter has a name and a type. You can have zero or more parameters.
-> ReturnType: Specifies the type of value the function returns. If the function doesn't return a value, you use (), the unit type.
{ ... }: The function body, containing the code that will be executed when the function is called.
return value;: Returns a value from the function. If the last expression in the function body is not a return statement, the value of that expression is automatically returned.

Example:

fn add(x: i32, y: i32) -> i32 {
    x + y // No explicit return statement, the result of the expression is returned
}

fn greet(name: &str) { // No return type, implicitly returns ()
    println!("Hello, {}!", name);
}

2. Calling a Function

To execute a function, you call it by its name, followed by parentheses containing any arguments needed:

fn main() {
    let sum = add(5, 3);
    println!("The sum is: {}", sum); // Output: The sum is: 8

    greet("Alice"); // Output: Hello, Alice!
}

3. Function Parameters

Type Annotations: Rust is statically typed, so you must specify the type of each parameter.
Passing by Value: By default, function parameters are passed by value. This means a copy of the argument is made and passed to the function. Changes made to the parameter inside the function do not affect the original variable.
Passing by Reference: To avoid copying and allow the function to modify the original variable, you can pass parameters by reference using the & operator.
```
fn modify_value(x: &mut i32) { // &mut indicates a mutable reference
    *x += 1; // Dereference the reference to modify the original value
}

fn main() {
    let mut num = 10;
    modify_value(&mut num);
    println!("The value of num is: {}", num); // Output: The value of num is: 11
}
```
- & (immutable reference): Allows the function to read the value but not modify it.
- &mut (mutable reference): Allows the function to both read and modify the value. You must declare the original variable as mut to allow a mutable reference.
Ownership and Borrowing: References are closely tied to Rust's ownership and borrowing rules. A function can have multiple immutable references to a value, but only one mutable reference at a time. This prevents data races.

4. Return Values

Explicit return: You can use the return keyword to explicitly return a value from a function.
Implicit Return: If the last expression in a function body is not terminated with a semicolon, its value is automatically returned. This is often preferred for concise code.

Returning Multiple Values: Rust allows functions to return multiple values as a tuple.

fn get_coordinates() -> (f64, f64) {
    (37.7749, -122.4194) // Latitude, Longitude
}

fn main() {
    let (latitude, longitude) = get_coordinates();
    println!("Latitude: {}, Longitude: {}", latitude, longitude);
}

5. Function Pointers

Function pointers allow you to pass functions as arguments to other functions. This is a powerful technique for creating flexible and reusable code.

fn apply(x: i32, f: fn(i32) -> i32) -> i32 {
    f(x)
}

fn square(x: i32) -> i32 {
    x * x
}

fn increment(x: i32) -> i32 {
    x + 1
}

fn main() {
    let result1 = apply(5, square);
    println!("Square of 5: {}", result1); // Output: Square of 5: 25

    let result2 = apply(5, increment);
    println!("Increment of 5: {}", result2); // Output: Increment of 5: 6
}

6. Closures

Closures are anonymous functions that can capture variables from their surrounding environment. They are similar to lambda expressions in other languages.

fn main() {
    let factor = 2;
    let multiply = |x: i32| x * factor; // Closure capturing 'factor'

    let result = multiply(5);
    println!("Result: {}", result); // Output: Result: 10
}

Key Takeaways:

Functions are essential for code organization and reusability.
Rust is statically typed, so you must specify parameter and return types.
Understand the difference between passing by value and passing by reference.
Leverage Rust's ownership and borrowing rules to write safe and efficient code.
Function pointers and closures provide powerful ways to work with functions as data.