RAII and Deterministic Cleanup

RAII and Custom Cleanup with the Drop Trait

In this lesson, you will learn how to implement the Drop trait to define exactly what happens when your custom types go out of scope.

Understanding RAII

RAII stands for "Resource Acquisition Is Initialization." In Rust, it means that a resource (like a file handle, a network connection, or a lock) is tied to the lifecycle of an object. When an object is created, it acquires the resource; when the object goes out of scope, the resource is automatically released. Because Rust knows exactly when a variable goes out of scope, this cleanup is deterministic—it happens at a predictable time without needing a garbage collector.

Implementing the Drop Trait

While Rust automatically cleans up basic memory, sometimes you need to perform "extra" work during destruction, such as closing a file or logging that a process has finished. You do this by implementing the Drop trait for your struct.

The Drop trait requires one method: drop. This method is called automatically by Rust when your object is about to be cleaned up.

struct Logger {
    name: String,
}

impl Drop for Logger {
    fn drop(&mut self) {
        println!("Shutting down logger: {}", self.name);
    }
}

fn main() {
    let _a = Logger { name: String::from("App") };
    let _b = Logger { name: String::from("Worker") };
    println!("Main function ending...");
} // _b and _a go out of scope here and are dropped in reverse order.

Why Determinism Matters

Because Rust calls drop the moment the variable leaves its scope, you don't have to guess when your cleanup code will run. In the example above, you will see the "Shutting down" messages printed before the program finishes. If you had created these inside an if block or a loop, the cleanup would have occurred immediately after the closing brace of that block. This ensures that resources are not held open a second longer than necessary.

Key Takeaway: The Drop trait allows you to hook into Rust’s ownership system to guarantee that custom cleanup logic executes exactly when a variable goes out of scope.