Ownership and Resource Management

In Rust, ownership manages not only heap memory, but every kind of finite operating system and application resource—including open file descriptors, network sockets, database transactions, mutex locks, and temporary directories. This design pattern is known as RAII (Resource Acquisition Is Initialization) and is powered in Rust by the Drop trait.

How the Drop Trait Connects Scope to Resource Cleanup

When a type implements std::ops::Drop, the compiler automatically invokes Drop::drop(&mut self) whenever an owned instance of that type goes out of scope (or is overwritten by reassignment):

pub trait Drop {
    fn drop(&mut self);
}

Acquire Resource (`File::create`, `mutex.lock()`)
       │
       v
Bound to Owner Variable (`let file = ...;`)
       │
       v
Use Resource Safely inside Scope
       │
       v
Scope Ends (`}`, early `return`, `?`, or `panic!` unwind)
       │
       v
Compiler automatically runs `Drop::drop(&mut file)` --> OS Resource Closed Immediately!

struct TempFile {
    path: String,
}

impl TempFile {
    fn create(path: &str) -> Self {
        println!("  [Init] Created temporary file '{path}'");
        Self { path: String::from(path) }
    }
}

impl Drop for TempFile {
    fn drop(&mut self) {
        println!("  [Drop] Automatically deleted temporary file '{}'", self.path);
    }
}

fn process_job() -> Result<(), &'static str> {
    let _temp = TempFile::create("/tmp/job_scratch.tmp");
    println!("  [Work] Processing job...");
    // Even if we return early with `Err` or `?`, `_temp` is guaranteed to be cleaned up!
    Err("simulated failure midway through job")
}

fn main() {
    let outcome = process_job();
    println!("Job finished with: {outcome:?}");
}

  [Init] Created temporary file '/tmp/job_scratch.tmp'
  [Work] Processing job...
  [Drop] Automatically deleted temporary file '/tmp/job_scratch.tmp'
Job finished with: Err("simulated failure midway through job")

Early Resource Release with std::mem::drop(x)

Rust does not allow calling x.drop() directly as a method (error[E0040]: explicit use of destructor method), because the compiler would still drop x a second time at the end of the block (causing a double free!).

Instead, to release a resource (such as a mutex lock or large buffer) before the end of the current block, pass it by value to std::mem::drop(x) (which is in the standard prelude as drop(x)). Its implementation is literally an empty function that takes ownership of x by value and lets it go out of scope immediately:

// How `std::mem::drop` is implemented in the standard library:
pub fn drop<T>(_x: T) {}

use std::sync::Mutex;

fn main() {
    let shared_counter = Mutex::new(10);

    let mut guard = shared_counter.lock().unwrap();
    *guard += 5;

    // Release the mutex lock immediately by moving `guard` into `drop()`:
    drop(guard);

    // Because `guard` was dropped early, locking `shared_counter` again on the same thread succeeds!
    println!("Counter after early unlock: {}", *shared_counter.lock().unwrap());
}

Counter after early unlock: 15