Rust - Ownership, Borrowing & Concurrency

1. Each value in Rust has an owner (a variable).
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value is dropped automatically.

When assigning or passing a variable by value:

At any given point in a program, you can have either:

References must always be valid for their entire lifetime.

Annotations used by the borrow checker to ensure references remain valid for a specific scope. They do not change runtime execution, but explicitly declare relationships between reference lifetimes to prevent dangling pointers (e.g., fn longest<'a>(x: &'a str, y: &'a str) -> &'a str).

Three deterministic compiler rules for inferring reference lifetimes without explicit annotations:
1. Each elided reference parameter gets a unique lifetime parameter.
2. If there is exactly one input lifetime parameter, it is assigned to all output lifetimes.
3. If &self or &mut self is an input parameter, its lifetime is assigned to all output lifetimes.

Allocates data directly on the heap while storing the pointer on the stack. Used for recursive types of unknown size at compile time, transferring ownership of large data without stack copies, or dynamic dispatch (Box<dyn Trait>).

Reference Counting smart pointer for single-threaded, shared ownership. Tracks reference counts and frees heap memory when the count reaches zero. Not thread-safe (does not implement Send or Sync).

Atomic Reference Counting smart pointer for thread-safe shared ownership across multiple threads. Uses atomic operations to update reference counts, enabling safe concurrently-shared data.