How do borrowing rules work in Rust?

02 Tem 04:24

Rust’s borrowing rules helped me leave behind the memory issues I used to face with pointers in C/C++, much like how you need to rely on `copy.deepcopy()` in Python before using `list.copy()`. When using `&mut`, the compiler enforces three simple but strict rules: you can either take a reference from a single variable, a reference from the owner with deep ownership, or a temporary reference (e.g., function return value). These rules prevent memory conflicts like data races during borrowing, enabling safe parallelism—similar to Go’s goroutines—solely through compiler guarantees. Lifetime analysis, on the other hand, calculates at compile time how long variables can borrow from each other, eliminating the "when will this be freed?" stress I felt when relying on Python’s garbage collector. In practice, when optimizing, using `String` instead of `&str` in structs or switching from `Option<&mut T>` to `RefCell<T>` keeps me out of trouble. Using tools like `Box::leak` or `lazy_static` to avoid memory copies feels like making a friendly deal with the compiler rather than threatening it, similar to how global variables work in Python.