🦀 Rust – Functions & Scope: Define, Call, and Control Execution Context

🧲 Introduction – Why Learn Functions and Scope in Rust?

Functions are fundamental units of logic reuse and abstraction. In Rust, functions come with strong type declarations, ownership awareness, and scoped variable rules that help manage memory and control logic predictably.

🎯 In this guide, you’ll learn:

• How to define and call functions in Rust
• How to use parameters and return values
• What scope means in Rust (local vs global)
• Code examples with output and full line-by-line breakdown

---

✅ Defining and Calling a Function

🔹 Code Example:

fn greet() {
    println!("Hello from Rust!");
}

fn main() {
    greet();
}

🧠 Explanation:

• fn greet() → Declares a function named greet with no parameters.
• println!() → Executes when greet() is called inside main.

📤 Output:

Hello from Rust!

---

🔢 Function with Parameters

🔹 Code Example:

fn print_sum(a: i32, b: i32) {
    println!("Sum: {}", a + b);
}

fn main() {
    print_sum(5, 7);
}

🧠 Explanation:

• fn print_sum(a: i32, b: i32) → Defines two integer parameters.
• Inside main(), it calls the function with 5 and 7.

📤 Output:

Sum: 12

---

🔁 Function with Return Value

🔹 Code Example:

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

fn main() {
    let result = square(4);
    println!("Square: {}", result);
}

🧠 Explanation:

• -> i32 → Declares the return type.
• Last line x * x returns value implicitly (no semicolon).
• Assigns return value to result and prints it.

📤 Output:

Square: 16

✅ You can also use return x * x;, but it’s idiomatic to return the last expression without ;.

---

🔃 Function with Conditional Return

🔹 Code Example:

fn is_even(n: i32) -> bool {
    if n % 2 == 0 {
        true
    } else {
        false
    }
}

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

🧠 Explanation:

• Function returns a bool.
• Evaluates condition and returns true or false.

📤 Output:

Is 4 even? true

---

📦 Variable Scope in Rust

Rust has block-level scoping—variables declared inside a block {} cannot be accessed outside.

🔹 Code Example:

fn main() {
    let x = 10;

    {
        let y = 20;
        println!("Inside block: x = {}, y = {}", x, y);
    }

    println!("Outside block: x = {}", x);
    // println!("y = {}", y); // Uncommenting this causes compile error
}

🧠 Explanation:

• x is accessible throughout main.
• y exists only within its inner block.

📤 Output:

Inside block: x = 10, y = 20
Outside block: x = 10

---

🔄 Shadowing Variables in Scope

🔹 Code Example:

fn main() {
    let x = 5;

    {
        let x = x * 2; // shadows outer x
        println!("Inner x: {}", x);
    }

    println!("Outer x: {}", x);
}

🧠 Explanation:

• let x = x * 2; creates a new x in inner scope.
• Outer x remains unchanged.

📤 Output:

Inner x: 10
Outer x: 5

---

🧱 Nested Functions (Inside Modules Only)

Rust does not support defining functions inside functions directly—except in specific scopes like closures or modules.

---

📌 Summary – Recap & Next Steps

Rust functions are expressive and safe, with strong type enforcement and scoped control. They encourage clear logic reuse while protecting memory through ownership and block scoping.

🔍 Key Takeaways:

• Define functions with fn, use explicit types for parameters and return
• Omit ; to return expressions implicitly
• Variables are block-scoped and follow ownership rules
• Use shadowing to redefine variables within a smaller scope

⚙️ Next: Explore Rust – Ownership and Borrowing to learn how function parameters and scope interact with memory safety.

---

❓FAQs

---

❓ Can I omit the return keyword in Rust?
✅ Yes. The last expression in a function (without a semicolon) is returned automatically.

---

❓ What is the difference between scope and lifetime?
✅ Scope is the visibility of a variable in code blocks. Lifetime is how long a reference is valid in memory (covered with borrowing/lifetimes).

---

❓ Can functions be overloaded in Rust?
❌ No. Rust does not support traditional function overloading. Use traits or different function names.

---

❓ Can functions return multiple values?
✅ Yes. Use tuples:

fn swap(x: i32, y: i32) -> (i32, i32) {
    (y, x)
}

---

Share Now :