Rust MCQ

Explanation

Rust was created by Graydon Hoare at Mozilla in 2006. The Rust Foundation was established in 2021 to steward the project.

Explanation

Rust's ownership system ensures memory safety at compile time with no runtime garbage collector. The borrow checker prevents use-after-free and data races.

Explanation

Rust's ownership model: each value has one owner. When the owner goes out of scope, the value is dropped (memory freed). Ownership can be moved but not copied by default.

Explanation

let s1 = String::from("hello"); let s2 = s1; — s1 is moved into s2. Using s1 after this is a compile error.

Explanation

Types like i32, bool, char, and tuples of Copy types implement Copy. let x = 5; let y = x; — x is still valid because integers are Copy.

Explanation

&T is an immutable reference; &mut T is a mutable reference. References are guaranteed to be valid (non-dangling) by the borrow checker.

Explanation

fn print(s: &String) borrows s without taking ownership. The original owner retains ownership after the function returns.

Explanation

The borrow checker enforces: at most one &mut T, or any number of &T at a time. This prevents data races at compile time.

Explanation

&str is a string slice; &[i32] is an integer slice. Slices hold a pointer and a length without owning the data.

Explanation

&str is a view into string data (can point to a String or string literal). String owns its data and can grow. Use &str for function parameters accepting both.

Explanation

enum Message { Quit, Move { x: i32, y: i32 }, Write(String) } — Rust enums are algebraic data types, far more powerful than C enums.

Explanation

Option<T> replaces null pointers. You must handle both Some(x) and None, preventing null pointer dereferences.

Explanation

Result is used for operations that can fail: fn open(path: &str) -> Result<File, io::Error>. Callers must handle both Ok and Err cases.

Explanation

let file = File::open("path")?; returns the Err to the caller if it fails, otherwise unwraps the Ok value. Replaces verbose match expressions.

Explanation

struct Point { x: f64, y: f64 } defines a named group of values. Structs are value types stored on the stack unless boxed.

Explanation

Traits (like Java interfaces or Haskell typeclasses) define shared behavior. trait Area { fn area(&self) -> f64; } implemented by Circle, Rectangle, etc.

Explanation

Lifetime annotations ('a) on references let the compiler verify references don't outlive their data: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str.

Explanation

The borrow checker is part of the Rust compiler. It checks that references are valid and that mutability rules are respected — all at compile time.

Explanation

match coin { Coin::Penny => 1, Coin::Nickel => 5, _ => 0 } is exhaustive — all cases must be handled.

Explanation

panic!("message") crashes the program (or thread). It's for unrecoverable errors. Use Result for recoverable errors.

Explanation

Box<T> puts T on the heap. Use Box when you need a heap allocation, a trait object (Box<dyn Trait>), or a recursive data type.

Explanation

Rc<T> (Reference Counted) allows multiple owners. The data is freed when the last Rc is dropped. Not Send/Sync — use Arc for multithreading.

Explanation

Arc<T> is the thread-safe version of Rc<T>, using atomic operations for the reference count. Use with Mutex<T> for shared mutable state across threads.

Explanation

Interior mutability allows mutation through an immutable reference. RefCell<T> enforces borrow rules at runtime, panicking on violations.

Explanation

use std::collections::HashMap; allows using HashMap directly instead of the full path.

Explanation

Cargo handles dependencies (Cargo.toml), building (cargo build), testing (cargo test), documentation (cargo doc), and publishing to crates.io.

Explanation

A crate is a binary (has main) or a library. crates.io is the package registry. Cargo.toml specifies crate dependencies.

Explanation

#[derive(Debug, Clone, PartialEq)] auto-generates the implementations of those traits for the struct or enum.

Explanation

println!("Value: {}", x) formats and prints to stdout with a newline. {} uses the Display trait; {:?} uses the Debug trait.

Explanation

Vec<T> grows dynamically. vec![1,2,3] or Vec::new() with push(). Elements are stored contiguously on the heap.

Explanation

v.iter().filter(|x| *x > 2).map(|x| x * 2).collect::<Vec<_>>() chains lazy iterator adaptors, executing only on collect().

Explanation

Use iter() for read-only access, iter_mut() for mutation, into_iter() when you want to consume and transform the collection.

Explanation

impl Drop for MyResource { fn drop(&mut self) { /* cleanup */ } } runs when the value goes out of scope, implementing RAII.

Explanation

impl Point { fn new(x: f64, y: f64) -> Self { ... } fn distance(&self) -> f64 { ... } } defines methods on Point.

Explanation

let double = |x| x * 2; captures no environment. Closures can capture by reference (&), mutable reference (&mut), or by value (move).

Explanation

FnOnce ⊇ FnMut ⊇ Fn. A function accepting Fn can be passed any closure. Closures implement the most specific trait based on how they capture.

Explanation

move || { use_data(data) } moves data into the closure. Required when passing closures to threads where the outer scope may not outlive the thread.

Explanation

fn largest<T: PartialOrd>(list: &[T]) -> T works for any type T that implements PartialOrd. Rust monomorphizes generics at compile time.

Explanation

When you use Vec<i32> and Vec<String>, Rust compiles two separate Vec implementations. This makes generics zero-cost but can increase binary size.

Explanation

Three elision rules: (1) each input ref gets its own lifetime; (2) one input → output gets same; (3) self method → output gets self's lifetime.

Explanation

Box<dyn Animal> or &dyn Animal is a fat pointer (data ptr + vtable ptr) that can hold any Animal implementor. Use when concrete types aren't known at compile time.

Explanation

fn f<T: Display>(x: T) is statically dispatched. fn g(x: &dyn Display) is dynamically dispatched via vtable indirection.

Explanation

Types are Send if sending them to another thread is safe. Most types are Send. Rc<T> is not Send (non-atomic reference counting).

Explanation

T: Sync means &T: Send. Mutex<T> is Sync even if T is not, because it serializes access.

Explanation

let data = Arc::new(Mutex::new(5)); let guard = data.lock().unwrap(); *guard += 1; — the guard releases the lock when dropped.

Explanation

async fn fetch() -> Result<...> { let resp = client.get(url).await?; } Futures are lazy state machines. Executors like tokio::main drive them.

Explanation

Futures implement trait Future { type Output; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>; }. They do nothing until polled by an executor.

Explanation

unsafe { *raw_ptr } allows raw pointer dereference. Use unsafe for FFI, performance-critical code, and implementing safe abstractions. The programmer assumes correctness.

Explanation

Raw pointers (*const T) don't guarantee non-null or valid memory. Creating them is safe; dereferencing requires unsafe.

Explanation

impl From<i32> for MyType { fn from(x: i32) -> Self { ... } } then i32::from(x) or x.into() both work.

Explanation

impl fmt::Display for Point { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "({},{})", self.x, self.y) } }

Explanation

Macros avoid code duplication. macro_rules! my_macro { ... } is declarative. proc macros (like serde's #[derive(Serialize)]) use the Rust compiler API.

Explanation

struct Meters(f64); and struct Kilograms(f64) are distinct types despite holding f64. Prevents accidental mixing of units while having zero runtime cost.

Explanation

struct Iter<'a, T> { ptr: *const T, _phantom: PhantomData<&'a T> } tells the compiler the Iter borrows T with lifetime 'a, enabling proper variance.

Explanation

Pin<P> guarantees the pointee won't be moved after pinning. Async/await creates self-referential state machines that would be invalidated by moves, so futures require Pin.

Explanation

Box<String> coerces to &String which coerces to &str. String::from("hello") can be passed as &str. This chain is performed automatically.

Explanation

Integers implement Copy — assignment copies automatically. String does not implement Copy; you must call .clone() to create a deep copy.

Explanation

type Thunk = Box<dyn Fn() + Send + 'static>; is a type alias. Unlike struct Newtype(T), a type alias IS the same type.

Explanation

fn f<T: ?Sized>(x: &T) allows passing str and [T] as well as Sized types. fn f<T>(x: &T) implicitly requires T: Sized.

Explanation

fn double_and_print(x: impl Display + Debug) is cleaner than generics for simple cases. It's static dispatch — the compiler generates a concrete implementation.

Explanation

Cow::Borrowed(&str) avoids allocation; Cow::Owned(String) owns data. Cow::to_mut() clones only when mutation is needed. Useful for APIs accepting both &str and String.

Explanation

BufReader<R> buffers reads from R into a 8KB buffer by default. Instead of one syscall per byte, you get one syscall per 8KB. Use flush() on BufWriter before dropping.

Explanation

let v = Vec::new() fails (can't infer T). let v: Vec<i32> = Vec::new() or Vec::<i32>::new() works. Iterator collect() often needs type annotation.

Explanation

"42".parse::<i32>().unwrap() or Vec::<i32>::new() uses turbofish when the compiler can't infer the type from context.

Explanation

RwLock.read() can be held by many threads simultaneously. RwLock.write() requires exclusive access. Use when reads are frequent and writes are rare.

Explanation

Procedural macros are separate crates (proc-macro = true) that receive TokenStream and return TokenStream. Used by serde, tokio, thiserror, and async-trait.

Explanation

#[derive(Error)] #[error("file {path} not found")] struct FileNotFound { path: String } generates Display and std::error::Error implementation.

Explanation

fn main() -> anyhow::Result<()> with ? on any error. file.read_to_string().context("reading config") adds context. Use thiserror for library errors, anyhow for apps.

Explanation

#[cfg(target_os = "linux")] fn platform_func() compiles only on Linux. cfg!(debug_assertions) is a bool constant. Used for platform-specific code and feature gates.

Explanation

fn zeros<const N: usize>() -> [i32; N] { [0; N] } creates zero arrays of any size. [T; N] arrays are const-generic over N in std.

Explanation

discriminant(&MyEnum::Foo) == discriminant(&MyEnum::Foo) is true. Lets you compare variant identity without destructuring, even when associated values differ.

Explanation

criterion benchmarks use black_box(input) to prevent the optimizer from constant-folding the benchmark away, ensuring accurate measurements.

Explanation

Because From<T> for U is implemented, U: Into<T> is auto-implemented. Function parameters using impl Into<String> accept both String and &str without explicit conversion.

Explanation

static LOG: OnceLock<Logger> = OnceLock::new(); LOG.get_or_init(|| Logger::new()) initializes exactly once across all threads. Replaces lazy_static! macro.

Explanation

std::sync::mpsc (multi-producer, single-consumer) provides channel::<T>() returning (Sender<T>, Receiver<T>). Sender can be cloned for multiple producers.

Explanation

trait HasMax { const MAX: u32; } impl HasMax for u8 { const MAX: u32 = 255; } provides a per-type compile-time constant.

Explanation

mem::forget(value) is safe but leaks resources. Used when transferring ownership to C code (ManuallyDrop is preferred), or implementing FFI handshakes.

Explanation

Pre-allocating with String::with_capacity(100) avoids multiple reallocations when pushing chars or appending substrings in a loop.

Explanation

counts.entry(word).and_modify(|c| *c += 1).or_insert(1) increments if present, inserts 1 if absent — all in one lookup.

Explanation

opt.map(|x| x + 1) returns Option<i32>. opt.and_then(|x| if x > 0 { Some(x) } else { None }) flattens Option<Option<i32>> into Option<i32>.

Explanation

NLL allows let x = v[0]; v.push(y); to compile — x's borrow ends before the push. Prior to NLL, any &v reference blocked mutation for the entire lexical scope.

Explanation

&'a T is covariant over 'a and T. &'a mut T is covariant over 'a but invariant over T (to prevent unsound mutations). PhantomData affects variance.

Explanation

Iterator has type Item (one per impl). If it were generic Iterator<Item>, you could implement multiple Iterators for the same type with different items.

Explanation

HRTB are needed when a closure must work with any lifetime. fn apply<F: for<'a> Fn(&'a i32) -> &'a i32>(f: F) expresses that F is valid for any concrete lifetime 'a.

Explanation

Polonius models borrows as facts and uses Datalog to compute liveness. It accepts some patterns that NLL incorrectly rejects while maintaining soundness.

Explanation

unsafe trait Scary {} means implementing it is unsafe. unsafe impl Scary for MyType {} promises the programmer satisfies the contract. Send and Sync are unsafe traits.

Explanation

#[global_allocator] static A: MyAllocator = MyAllocator; replaces the default allocator. Used for embedded systems, tracking allocations, or custom memory management.

Explanation

Specialization (RFC 1210, nightly-only) allows a blanket impl to be overridden by a more specific one. Used by the standard library (e.g., ToString being faster for types that impl Display).

Explanation

Rust's iterator chains, closures, and monomorphized generics are inlined and optimized to tight loops by LLVM, matching hand-optimized C performance.

Explanation

In Rust async, dropping a future stops it without any explicit cancel API. This is efficient but requires careful design around cancellation safety (e.g., don't cancel mid-transaction).

Explanation

std only provides Future and async/await syntax. tokio is optimized for network I/O. embassy runs on embedded (no_std). smol is minimal. Different use cases need different executors.

Explanation

tokio::spawn creates Tasks — lightweight async work units. thread::spawn creates OS threads with ~8MB stack. You can run millions of Tasks; thousands of threads struggle.

Explanation

cargo miri test runs tests under the Miri interpreter, catching UB that ASan/TSan might miss (invalid enum discriminants, uninitialized reads). Slow but thorough.

Explanation

MIR is Rust's internal representation after type checking. The borrow checker runs on MIR. It's also used by Miri, cargo check optimizations, and constant evaluation.

Explanation

Soundness is Rust's core guarantee. A library with unsafe internals is sound if its safe interface cannot be misused to cause UB. Unsound APIs are bugs.

Explanation

Stacked Borrows (Miri uses it) defines a stack of "borrows" per memory location. Accessing via an invalidated borrow or creating forbidden aliasing is UB.

Explanation

The UCG (unstable, evolving) specifies allowed behaviors for unsafe code: layout guarantees, pointer provenance, aliasing. Violating UCG is UB even if it appears to work.

Explanation

RwLock has higher acquisition overhead than Mutex. For write-heavy or short-duration access, Mutex may outperform. Measure before switching.

Explanation

Async state machines contain references to their own stack variables. Pin prevents moves after these references are created. unsafe impl Unpin on a self-referential type is unsound.

Explanation

Strict provenance (ptr::from_exposed_addr, ptr.addr(), ptr.with_addr()) preserves pointer provenance information, making Rust's memory model compatible with address sanitizers and formal verification.