Rust flashcards, generated for you.

Each value has exactly one owner at a time. When the owner goes out of scope, the value is dropped. Ownership can be transferred (moved) to another binding.

For non-Copy types (String, Vec, etc.), ownership is *moved*—the original binding becomes invalid. For Copy types (i32, bool, etc.), the value is copied and both bindings remain valid.

Borrowing lets you reference a value without taking ownership. Immutable borrow (&T): read-only, multiple allowed. Mutable borrow (&mut T): exclusive write access, only one at a time per scope.

The borrow checker enforces: you cannot have mutable and immutable borrows of the same value simultaneously. Either multiple immutable borrows OR one mutable borrow—not both.

A lifetime is how long a reference is valid. Rust uses lifetime annotations ('a) to ensure references don't outlive the data they point to, preventing dangling pointers at compile time.

Ownership of the String moves to `y`. Using `x` afterward is a compile error. This applies to all non-Copy types. Use `clone()` or borrowing if you need to keep `x`.

`&String` is a reference to an owned String (heap-allocated). `&str` is a string slice—a view into a sequence of UTF-8 bytes (borrowed, no ownership). `&str` is more flexible and preferred for function parameters.

Rust allows only one mutable borrow at a time. `r1` and `r2` are both mutable references to `x` in the same scope, violating the rule. Even if you don't use r2, having it declared is an error.

`panic!` is unrecoverable—it stops the program. `Result<T, E>` is recoverable error handling (Ok(T) or Err(E)). Use `Result` for expected errors; `panic!` for bugs or impossible states.

The `?` operator unwraps a `Result` or `Option`: if Ok/Some, returns the value; if Err/None, returns early from the function with that error/None. Only usable in functions that return `Result` or `Option` (or functions that implement `Try`).