Advanced Features and Patterns

Rust’s Advanced Superpowers: Const Functions, Static Variables, RAII & Builder Pattern

🏰 The Tale of the Four Guardians

Imagine you’re building a magical castle. This castle has four special guardians that help keep everything running smoothly:

1. The Time-Freezer (Const Functions) - Does math at building time so the castle opens faster
2. The Eternal Guardian (Static Variables) - Stays awake forever, remembering things for everyone
3. The Cleanup Fairy (RAII Pattern) - Automatically cleans up messes when you leave a room
4. The Step-by-Step Builder (Builder Pattern) - Helps you build complex things piece by piece

Let’s meet each one!

⏰ Const Functions: The Time-Freezer

What’s the Magic?

Think of baking cookies. You could calculate how much flour you need every time someone wants a cookie. OR you could figure it out once, write it on a card, and just read the card!

Const functions do math when your program is being built (compiled), not when it’s running. This makes your program faster!

Real Life Example

Imagine your teacher says: “What’s 5 + 5?”

• Without const: You think… 5… plus 5… equals… 10!
• With const: You already know it’s 10 because you calculated it at home!

Simple Code Example

// This function runs at COMPILE TIME
const fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

// The answer (15) is calculated
// BEFORE the program even runs!
const RESULT: i32 = add_numbers(10, 5);

fn main() {
    // No calculation needed -
    // it's already 15!
    println!("Result: {}", RESULT);
}

What Can Const Functions Do?

graph TD
    A["Const Functions Can"] --> B["✅ Basic Math"]
    A --> C["✅ Create Arrays"]
    A --> D["✅ Simple Logic"]
    A --> E["❌ No File Reading"]
    A --> F["❌ No Network Calls"]

Why Use Them?

🗼 Static Variables: The Eternal Guardian

What’s the Magic?

Imagine a bulletin board in your school that everyone can read. It stays there forever, from the first day of school until the last. That’s a static variable!

Static variables live for the entire program. They’re like a shared notebook that everyone can peek at.

Real Life Example

Think of a score counter in an arcade:

• The machine turns on → Counter starts at 0
• Player 1 plays → Counter goes up
• Player 2 plays → They see Player 1’s high score!
• Machine stays on all day → Counter remembers everything

Simple Code Example

// This variable lives FOREVER
// It's the same for everyone
static GAME_NAME: &str = "Rust Adventure";

// Mutable static needs unsafe
// (because sharing is tricky!)
static mut PLAYER_COUNT: i32 = 0;

fn main() {
    println!("Welcome to {}", GAME_NAME);

    // Changing shared data needs
    // special permission (unsafe)
    unsafe {
        PLAYER_COUNT += 1;
        println!("Players: {}", PLAYER_COUNT);
    }
}

Static vs Const: What’s Different?

graph TD
    A["Static"] --> B["Has a fixed memory address"]
    A --> C["Can be mutable with unsafe"]
    A --> D["Lives entire program"]

    E["Const"] --> F["Inlined/copied everywhere"]
    E --> G["Always immutable"]
    E --> H["No memory address"]

Quick Comparison

🧹 RAII Pattern: The Cleanup Fairy

What’s the Magic?

RAII stands for “Resource Acquisition Is Initialization” - but think of it as the Cleanup Fairy!

When you enter a room (create something), the fairy notes what you brought. When you leave (scope ends), she automatically cleans up!

Real Life Example

Think of a library book:

1. You borrow the book (acquire resource)
2. You read it (use the resource)
3. When you’re done, it automatically goes back (cleanup happens)

You don’t have to remember to return it - it happens automatically!

Simple Code Example

struct Book {
    title: String,
}

// When Book is created, it "borrows" memory
// When Book goes away, cleanup happens!
impl Drop for Book {
    fn drop(&mut self) {
        println!("📚 Returning: {}", self.title);
    }
}

fn main() {
    println!("Entering library...");

    {
        // Book is created here
        let book = Book {
            title: String::from("Rust Magic"),
        };
        println!("Reading: {}", book.title);

        // Scope ends here - DROP runs!
    } // 📚 Returning: Rust Magic

    println!("Left the library!");
}

How RAII Works

graph TD
    A["Enter Scope"] --> B["Create Resource"]
    B --> C["Use Resource Freely"]
    C --> D["Leave Scope"]
    D --> E["Drop Called Automatically"]
    E --> F["Memory Freed"]
    E --> G["Files Closed"]
    E --> H["Locks Released"]

Common RAII Resources

🏗️ Builder Pattern: The Step-by-Step Guide

What’s the Magic?

Imagine ordering a custom pizza:

• “I want a large pizza”
• “Add cheese”
• “Add pepperoni”
• “Now bake it!”

The Builder Pattern lets you create complex things step by step, making it impossible to mess up!

Real Life Example

Building a LEGO castle:

1. Start with the base
2. Add walls
3. Add towers
4. Add the roof
5. Done! You have a castle!

Each step is clear. You can’t put the roof before the walls!

Simple Code Example

struct Pizza {
    size: String,
    cheese: bool,
    pepperoni: bool,
}

struct PizzaBuilder {
    size: String,
    cheese: bool,
    pepperoni: bool,
}

impl PizzaBuilder {
    fn new() -> Self {
        PizzaBuilder {
            size: String::from("medium"),
            cheese: false,
            pepperoni: false,
        }
    }

    fn size(mut self, size: &str) -> Self {
        self.size = size.to_string();
        self  // Return self for chaining!
    }

    fn cheese(mut self) -> Self {
        self.cheese = true;
        self
    }

    fn pepperoni(mut self) -> Self {
        self.pepperoni = true;
        self
    }

    fn build(self) -> Pizza {
        Pizza {
            size: self.size,
            cheese: self.cheese,
            pepperoni: self.pepperoni,
        }
    }
}

Using the Builder

fn main() {
    let my_pizza = PizzaBuilder::new()
        .size("large")
        .cheese()
        .pepperoni()
        .build();

    println!("Size: {}", my_pizza.size);
    // Output: Size: large
}

Builder Pattern Flow

graph TD
    A["Start: Builder::new"] --> B[".option1"]
    B --> C[".option2"]
    C --> D[".option3"]
    D --> E[".build"]
    E --> F["Final Object Created!"]

Why Builder Pattern?

🎯 Putting It All Together

Here’s how all four concepts can work together:

// 1. CONST FUNCTION - compile time
const fn default_health() -> i32 { 100 }

// 2. STATIC - lives forever
static GAME_VERSION: &str = "1.0";

// 3. RAII - auto cleanup
struct Player {
    name: String,
    health: i32,
}

impl Drop for Player {
    fn drop(&mut self) {
        println!("👋 {} left!", self.name);
    }
}

// 4. BUILDER - step by step
struct PlayerBuilder {
    name: String,
    health: i32,
}

impl PlayerBuilder {
    fn new(name: &str) -> Self {
        PlayerBuilder {
            name: name.to_string(),
            health: default_health(), // const!
        }
    }

    fn health(mut self, hp: i32) -> Self {
        self.health = hp;
        self
    }

    fn build(self) -> Player {
        println!("Using {}", GAME_VERSION);
        Player {
            name: self.name,
            health: self.health,
        }
    }
}

🌟 Remember This!

You now have four superpowers for writing cleaner, safer, faster Rust code! 🦀✨