Rust Programming Language - Ownership, Borrowing & Concurrency Flashcards

Question 1

Three Core Rules of Ownership

Accepted Answer

Rust's memory management relies on three fundamental rules:
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 automatically dropped.

Question 2

Move Semantics

Accepted Answer

When a variable holding non-`Copy` data is assigned to another variable, passed to a function, or returned, ownership is transferred (**moved**). The original variable becomes uninitialized and invalid for further use.

Question 3

`Copy` vs. `Clone` Traits

Accepted Answer

- **`Copy`**: Marker trait for types stored on the stack (e.g., `i32`, `bool`). Assignment performs an implicit, cheap bitwise copy without invalidating the source.
- **`Clone`**: Trait for explicit, potentially expensive deep copying (e.g., `String`, `Vec<T>`), explicitly invoked via `.clone()`.

Question 4

Borrowing and Reference Types

Accepted Answer

Borrowing allows accessing data without taking ownership.
- **Immutable Reference (`&T`)**: Grants read-only access to the data.
- **Mutable Reference (`&mut T`)**: Grants exclusive read-and-write access to the data.

Question 5

The Reference Rule (Aliasing XOR Mutability)

Accepted Answer

At any given point in a scope, you can have **either**:
- Any number of immutable references (`&T`) to a resource, **OR**
- Exactly one mutable reference (`&mut T`) to a resource.

This rule eliminates data races at compile time.

Question 6

Dangling Reference Prevention

Accepted Answer

A dangling reference points to invalid memory location. Rust's borrow checker prevents this at compile time by ensuring references never outlive the underlying data they reference.

Question 7

Lifetimes (`'a`)

Accepted Answer

Lifetimes are generic parameters used by the borrow checker to validate that references are valid for a specific duration. Syntax: `&'a T` or `&'a mut T`. They describe lifetime relationships without modifying actual runtime allocation lifetimes.

Question 8

Lifetime Elision Rules

Accepted Answer

Deterministic compiler rules for implicitly inferring lifetimes in function signatures:
1. Each input reference parameter receives its own lifetime parameter.
2. If there is exactly one input lifetime, it is assigned to all output lifetimes.
3. If one input parameter is `&self` or `&mut self`, its lifetime is assigned to all output lifetimes.

Question 9

The `'static` Lifetime

Accepted Answer

- **Reference (`&'static T`)**: Data lives for the entire duration of the program (e.g., string literals `&'static str`).
- **Trait Bound (`T: 'static`)**: The type `T` contains no non-static references, meaning instances can be owned indefinitely (crucial for thread spawning).

Question 10

Traits

Accepted Answer

A `trait` defines shared behavior (analogous to interfaces in other languages) by declaring a set of methods that implementing types must provide:

```rust
trait Summarizable {
    fn summarize(&self) -> String;
}
```

Question 11

Trait Bounds

Accepted Answer

Trait bounds restrict generic parameters to types implementing specific behaviors:

```rust
fn notify<T: Display + Summarizable>(item: &T) {
    // Method body
}
```
Alternative syntax uses a `where` clause for complex bounds.

Question 12

`Option<T>` Enum

Accepted Answer

Rust's null-safety mechanism that forces explicit handling of presence or absence:

```rust
enum Option<T> {
    Some(T),
    None,
}
```

Question 13

`Result<T, E>` Enum

Accepted Answer

The standard enum used for recoverable error handling:

```rust
enum Result<T, E> {
    Ok(T),
    Err(E),
}
```
Requires handling both success (`Ok`) and failure (`Err`) outcomes.

Question 14

The `?` (Question Mark) Operator

Accepted Answer

A shorthand operator for error propagation. Applied to `Result` or `Option` values:
- If `Ok(val)` / `Some(val)`, unwraps and yields `val`.
- If `Err(err)` / `None`, immediately returns from the surrounding function with that `Err` / `None`.

Question 15

Thread Spawning (`std::thread::spawn`)

Accepted Answer

Spawns a native OS thread to execute code concurrently:

```rust
use std::thread;

let handle = thread::spawn(|| {
    // Code executed in child thread
});

handle.join().unwrap(); // Wait for thread termination
```

Question 16

`move` Closures in Threads

Accepted Answer

The `move` keyword forces a closure to take full ownership of captured variables from its environment rather than borrowing them. It is required when passing closures to `thread::spawn` because the child thread may outlive the parent scope.

Question 17

`mpsc` Channels

Accepted Answer

Provides **M**ulti-**P**roducer, **S**ingle-**C**onsumer communication between threads:

```rust
use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
tx.send(data).unwrap();
let received = rx.recv().unwrap();
```

Question 18

`Arc<T>` (Atomic Reference Counting)

Accepted Answer

A thread-safe reference-counting pointer that enables shared read-only ownership of heap-allocated data across multiple threads. Uses atomic operations for reference counter updates unlike `Rc<T>`.

Question 19

`Mutex<T>` and Lock Poisoning

Accepted Answer

Provides thread-safe interior mutability by enforcing mutual exclusion via `.lock()`.
- **RAII Unlocking**: Mutex guard releases the lock automatically when dropped.
- **Lock Poisoning**: If a thread panics while holding a `Mutex`, the mutex becomes poisoned, and subsequent `.lock()` calls return an `Err`.

Question 20

`Send` and `Sync` Auto Traits

Accepted Answer

- **`Send`**: Indicates ownership of the type can be transferred across thread boundaries safely.
- **`Sync`**: Indicates it is safe for multiple threads to access references (`&T`) of the type concurrently (`T` is `Sync` if `&T` is `Send`).

Rust Programming Language - Ownership, Borrowing & Concurrency

Card Preview

Related Flashcard Sets

Classical Mechanics - Kinematics, Dynamics & Energy

CFA Level 1 - Investment Tools & Ethics

BIO102 - Cell Biology & Genetics Fundamentals

Classical Mechanics - Newtonian Laws & Energy Conservation