Rust Contagious Borrow Issue
6 months ago
- #Borrow-Checker
- #Rust
- #Ownership
- Rust's ownership system is tree-shaped, ensuring each object has exactly one parent.
- Mutable borrows in Rust are exclusive, preventing other borrows to the same object.
- Borrowing in Rust is contagious; borrowing a child indirectly borrows its parent.
- Tree-shaped references are simple in Rust, while shared references complicate things.
- For immutable shared objects, use `Rc` (single-threaded) or `Arc` (multi-threaded).
- Mutable shared objects are borrow-check-unfriendly; solutions include data-oriented design and split borrows.
- Circular references in Rust require careful handling to avoid memory leaks.
- Contagious borrow issues arise when borrowing a part forces borrowing the whole.
- Solutions to contagious borrow include removing getters/setters and using interior mutability.
- Deferred mutation treats changes as data, enabling serialization and parallel processing.
- Avoiding in-place mutation via immutable data structures can prevent borrow conflicts.
- Split borrows allow borrowing separate fields of a struct within the same scope.
- Manual index management in loops can avoid iterator-related borrow issues.
- Cloning data or using `Rc`/`Arc` can resolve borrow conflicts but may impact performance.
- Circular references in programming are useful but require weak references (`Weak`) to prevent leaks.
- Using IDs or handles instead of direct references can simplify ownership in complex data structures.
- Interior mutability (`Cell`, `RefCell`, `Mutex`) allows mutation through immutable references.
- Rust's locks are non-reentrant, requiring careful scope management to avoid deadlocks.
- `Arc` performance degrades under contention; alternatives like `trc` or `hybrid_rc` can help.
- Bump allocators offer fast allocation but defer individual deallocations.
- Unsafe Rust bypasses borrow checks but requires careful handling to avoid undefined behavior.
- Polonius borrow checker will improve branch-related borrow analysis.
- `Send` and `Sync` traits ensure thread-safe data sharing in Rust.
- Tokio requires futures to be `Send` and `'static` for cross-thread scheduling.
- Temporary lifetime extension and reborrowing are implicit behaviors affecting borrow semantics.
- Cloning `Arc` before moving into async closures ensures proper ownership.
- Rust's constraints favor data-oriented design over OOP, reducing flexibility but improving safety.
- Memory safety in Rust doesn't eliminate all security risks (e.g., XSS, SQL injection).
- Immutable data structures prevent accidental mutations and simplify rollback scenarios.
- Rust's borrow checker rejects some valid code, requiring workarounds or design changes.