Rust flashcards, generated for you.

Ownership is Rust's core memory management system: each value has one owner, and when the owner drops, the value is freed. This prevents double-frees and null pointer bugs without garbage collection.

Ownership moves from x to y. x is no longer valid and cannot be used afterward. This is called a 'move,' and attempting to use x will cause a compile error.

Copying duplicates the value on the stack (cheap); moving transfers ownership. Primitive types (i32, bool, char) implement Copy and are copied by default. Complex types (String, Vec) move by default.

A reference is a non-owning pointer to a value. & creates an immutable reference (borrows the value without taking ownership). Multiple immutable references are allowed; you cannot modify through an immutable reference.

A mutable reference allows modification of the borrowed value. Key rule: only ONE mutable reference can exist to a value at a time in a given scope. You cannot mix mutable and immutable references simultaneously.

The borrow checker is the compiler mechanism that enforces ownership and borrowing rules at compile time. It prevents data races, use-after-free, and double-frees by ensuring references are valid.

A lifetime parameter (e.g., 'a) tracks how long a reference is valid. Rust requires them when a function returns a reference or holds references in structs, to ensure returned/stored references don't outlive their referents.

unwrap() returns the value or panics if None/Err. expect() does the same with a custom panic message. The ? operator returns early with the error if Err, or continues with the value if Ok—no panic.

Traits define shared behavior (methods) that types can implement. They enable compile-time (generics + trait bounds) and runtime (trait objects) polymorphism. Example: impl Display for MyStruct.

'static means the reference/value lives for the entire program duration. A normal lifetime parameter (e.g., 'a) is a variable placeholder for any lifetime. 'static is the longest possible lifetime.