Rust Programming Practice Exam

Question 1 Rust Programming

What is a closure in Rust?

Send means a type can be transferred to another thread.
Sync means a type can be referenced from multiple threads (i.e., &T is Send).
Most types implement both automatically. Rc<T> is neither, while Arc<T> is both. String is an owned, heap-allocated, growable UTF-8 string.
&str is a borrowed string slice — a reference to UTF-8 data. String literals are &'static str. Use &str for function parameters when you only need to read. An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move).

Question 2 Rust Programming

What is ownership in Rust?

Use an impl block:

impl User {
  fn greet(&self) -> String {
    format!("Hi, {}", self.name)
  }
}

The first parameter is typically &self, &mut self, or self. Ownership is Rust's core memory management concept. Each value has exactly one owner, and when the owner goes out of scope, the value is dropped (freed). This prevents memory leaks and double frees at compile time. Result<T, E> represents success or failure:
enum Result<T, E> { Ok(T), Err(E) }
It is the standard way to handle recoverable errors in Rust, used extensively in I/O and parsing. Generics allow writing code that works with multiple types:
fn largest<T: PartialOrd>(list: &[T]) -> &T
The compiler performs monomorphization — generating specialized code for each concrete type used, so there is zero runtime cost.

Question 3 Rust Programming

What is the difference between &T and &mut T?

&T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it. Option<T> represents a value that may or may not exist:
enum Option<T> { Some(T), None }
It replaces null from other languages and forces you to explicitly handle the absence of a value. 'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. A module mod foo; tells the compiler to look for foo.rs or foo/mod.rs. Since Rust 2018, foo.rs with a sibling directory foo/ is preferred over foo/mod.rs.

Question 4 Rust Programming

What are raw pointers in Rust?

let evens: Vec<i32> = (1..=10)
  .filter(|x| x % 2 == 0)
  .map(|x| x * x)
  .collect();

This filters even numbers 2–10, squares them, and collects into a Vec. Result: [4, 16, 36, 64, 100]. Raw pointers *const T and *mut T are like C pointers — they can be null, dangling, or aliased. Creating them is safe, but dereferencing requires an unsafe block:

let p: *const i32 = &x;
unsafe { println!("{}", *p); }

Use an impl block:

impl User {
  fn greet(&self) -> String {
    format!("Hi, {}", self.name)
  }
}

The first parameter is typically &self, &mut self, or self. dyn Trait enables dynamic dispatch via a vtable (virtual method table):
fn draw(shape: &dyn Drawable)
Unlike generics (static dispatch), the concrete type is resolved at runtime. Trade-off: slight runtime cost, but allows heterogeneous collections.

Question 5 Rust Programming

What is a struct in Rust?

Channels provide message passing between threads via std::sync::mpsc (multiple producer, single consumer):

let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
let val = rx.recv().unwrap();

A struct is a custom data type that groups related fields. Example:
struct User { name: String, age: u32 }
Rust has three kinds: named-field structs, tuple structs, and unit structs. 'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming.

Question 6 Rust Programming

What are some commonly derived traits in Rust?

Copy allows implicit bitwise copies on assignment (stack-only types like i32, bool).
Clone requires an explicit .clone() call and can perform deep copies. All Copy types must also implement Clone. An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move). Common derivable traits include:

Debug — enables {:?} formatting
Clone / Copy — value duplication
PartialEq / Eq — equality comparison
PartialOrd / Ord — ordering
Hash — hashing support

Use #[derive(Debug, Clone)].

Question 7 Rust Programming

What is while let in Rust?

std::fmt::Display enables user-facing string formatting with {}:

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

Unlike Debug, it cannot be derived automatically. while let loops as long as a pattern matches:

while let Some(val) = stack.pop() {
  println!("{}", val);
}

Useful for iterating until an Option returns None. Trait bounds constrain generic types to those implementing specific traits:
fn print_summary<T: Summary>(item: &T)
Or using where syntax:
fn print_summary<T>(item: &T) where T: Summary Ownership is Rust's core memory management concept. Each value has exactly one owner, and when the owner goes out of scope, the value is dropped (freed). This prevents memory leaks and double frees at compile time.

Question 8 Rust Programming

What is the difference between panic! and Result?

panic! is for unrecoverable errors — it unwinds the stack and crashes the thread.
Result is for recoverable errors — the caller decides how to handle the failure. Prefer Result in library code. Option<T> represents a value that may or may not exist:
enum Option<T> { Some(T), None }
It replaces null from other languages and forces you to explicitly handle the absence of a value. String is an owned, heap-allocated, growable UTF-8 string.
&str is a borrowed string slice — a reference to UTF-8 data. String literals are &'static str. Use &str for function parameters when you only need to read. From<T> defines how to create a type from another:
impl From<&str> for String
Into<T> is the reciprocal — implementing From automatically provides Into. Widely used for ergonomic type conversions and error handling.

Question 9 Rust Programming

What is the Vec type?

Iterators implement the Iterator trait, which requires a next() method returning Option<Item>. They are lazy — they do nothing until consumed by methods like collect(), sum(), or for loops. Use an impl block:

impl User {
  fn greet(&self) -> String {
    format!("Hi, {}", self.name)
  }
}

The first parameter is typically &self, &mut self, or self. Use std::thread::spawn:

let handle = thread::spawn(|| {
  println!("Hello from thread!");
});
handle.join().unwrap();

Closures sent to threads typically need move to own their data. Vec<T> is a growable, heap-allocated array. Create with:
let v = vec![1, 2, 3];
Key methods: push(), pop(), len(), iter(). It owns its elements and drops them when it goes out of scope.

Question 10 Rust Programming

Give an example of chaining iterator methods.

HashMap<K, V> stores key-value pairs with O(1) average lookup:

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", 42);
let val = map.get("key");

Keys must implement Eq and Hash.

let evens: Vec<i32> = (1..=10)
  .filter(|x| x % 2 == 0)
  .map(|x| x * x)
  .collect();

This filters even numbers 2–10, squares them, and collects into a Vec. Result: [4, 16, 36, 64, 100]. &T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it. Borrowing lets you reference a value without taking ownership. You create a reference with &. The original owner retains ownership while the borrower can read (or write, if mutable) the data.

Question 11 Rust Programming

How do you annotate lifetimes on a function?

Use lifetime parameters in angle brackets: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. This tells the compiler the returned reference lives at least as long as the shorter of x and y. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming. Rust is a systems programming language focused on safety, speed, and concurrency. It achieves memory safety without a garbage collector through its ownership system. Copy allows implicit bitwise copies on assignment (stack-only types like i32, bool).
Clone requires an explicit .clone() call and can perform deep copies. All Copy types must also implement Clone.

Question 12 Rust Programming

How do you implement methods on a struct?

Common derivable traits include:

Debug — enables {:?} formatting
Clone / Copy — value duplication
PartialEq / Eq — equality comparison
PartialOrd / Ord — ordering
Hash — hashing support

Use #[derive(Debug, Clone)]. 'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. Generics allow writing code that works with multiple types:
fn largest<T: PartialOrd>(list: &[T]) -> &T
The compiler performs monomorphization — generating specialized code for each concrete type used, so there is zero runtime cost. Use an impl block:

impl User {
  fn greet(&self) -> String {
    format!("Hi, {}", self.name)
  }
}

The first parameter is typically &self, &mut self, or self.

Question 13 Rust Programming

What is the From and Into trait?

A struct is a custom data type that groups related fields. Example:
struct User { name: String, age: u32 }
Rust has three kinds: named-field structs, tuple structs, and unit structs. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming. Adapters transform iterators lazily (e.g., map(), filter(), take()).
Consumers drive iteration and produce a result (e.g., collect(), sum(), count(), for_each()). From<T> defines how to create a type from another:
impl From<&str> for String
Into<T> is the reciprocal — implementing From automatically provides Into. Widely used for ergonomic type conversions and error handling.

Question 14 Rust Programming

What is a module in Rust?

Modules organize code into namespaces using mod:

mod network {
  pub fn connect() { }
}

Items are private by default; use pub to make them public. Modules can be in separate files. An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. Trait bounds constrain generic types to those implementing specific traits:
fn print_summary<T: Summary>(item: &T)
Or using where syntax:
fn print_summary<T>(item: &T) where T: Summary panic! is for unrecoverable errors — it unwinds the stack and crashes the thread.
Result is for recoverable errors — the caller decides how to handle the failure. Prefer Result in library code.

Question 15 Rust Programming

What is a trait in Rust?

A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move). Raw pointers *const T and *mut T are like C pointers — they can be null, dangling, or aliased. Creating them is safe, but dereferencing requires an unsafe block:

let p: *const i32 = &x;
unsafe { println!("{}", *p); }

'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming.

Question 16 Rust Programming

What is pattern matching in Rust?

These traits describe how closures capture variables:

Fn — captures by immutable reference
FnMut — captures by mutable reference
FnOnce — captures by value (can only be called once)

Every closure implements FnOnce; some also implement FnMut or Fn. Pattern matching uses match to destructure and branch on values:

match shape {
  Shape::Circle(r) => ...,
  Shape::Rectangle(w, h) => ...,
}

The compiler ensures all variants are handled (exhaustiveness). A crate is the smallest compilation unit. It can be a binary crate (with a main function) or a library crate. External crates are published on crates.io and added via Cargo.toml. unsafe blocks let you perform operations the compiler cannot verify:

Dereference raw pointers
Call unsafe functions
Access mutable statics
Implement unsafe traits
Access union fields

Use sparingly and document invariants.

Question 17 Rust Programming

What are generics in Rust?

Use impl Trait for Type:

impl Summary for Article {
  fn summarize(&self) -> String {
    format!("{}", self.title)
  }
}

Raw pointers *const T and *mut T are like C pointers — they can be null, dangling, or aliased. Creating them is safe, but dereferencing requires an unsafe block:

let p: *const i32 = &x;
unsafe { println!("{}", *p); }

A struct is a custom data type that groups related fields. Example:
struct User { name: String, age: u32 }
Rust has three kinds: named-field structs, tuple structs, and unit structs. Generics allow writing code that works with multiple types:
fn largest<T: PartialOrd>(list: &[T]) -> &T
The compiler performs monomorphization — generating specialized code for each concrete type used, so there is zero runtime cost.

Question 18 Rust Programming

What is if let in Rust?

Pattern matching uses match to destructure and branch on values:

match shape {
  Shape::Circle(r) => ...,
  Shape::Rectangle(w, h) => ...,
}

The compiler ensures all variants are handled (exhaustiveness). if let is a concise way to match a single pattern:

if let Some(val) = my_option {
  println!("{}", val);
}

It's syntactic sugar for a match with one arm and a wildcard. Use when you only care about one variant. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move). Channels provide message passing between threads via std::sync::mpsc (multiple producer, single consumer):

let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
let val = rx.recv().unwrap();

Question 19 Rust Programming

What are channels in Rust?

An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. Trait bounds constrain generic types to those implementing specific traits:
fn print_summary<T: Summary>(item: &T)
Or using where syntax:
fn print_summary<T>(item: &T) where T: Summary &T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it. Channels provide message passing between threads via std::sync::mpsc (multiple producer, single consumer):

let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
let val = rx.recv().unwrap();

Question 20 Rust Programming

What is the 'static lifetime?

Ownership is Rust's core memory management concept. Each value has exactly one owner, and when the owner goes out of scope, the value is dropped (freed). This prevents memory leaks and double frees at compile time. A crate is the smallest compilation unit. It can be a binary crate (with a main function) or a library crate. External crates are published on crates.io and added via Cargo.toml. 'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. dyn Trait enables dynamic dispatch via a vtable (virtual method table):
fn draw(shape: &dyn Drawable)
Unlike generics (static dispatch), the concrete type is resolved at runtime. Trade-off: slight runtime cost, but allows heterogeneous collections.

Question 21 Rust Programming

What is the difference between Rc and Arc?

unsafe blocks let you perform operations the compiler cannot verify:

Dereference raw pointers
Call unsafe functions
Access mutable statics
Implement unsafe traits
Access union fields

Use sparingly and document invariants. Both are reference-counted smart pointers for shared ownership.
Rc<T> — single-threaded only, uses non-atomic counter (faster).
Arc<T> — thread-safe, uses atomic counter (slight overhead).
Use Arc when sharing data across threads; Rc otherwise. An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. From<T> defines how to create a type from another:
impl From<&str> for String
Into<T> is the reciprocal — implementing From automatically provides Into. Widely used for ergonomic type conversions and error handling.

Question 22 Rust Programming

What is unsafe Rust?

&T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it. unsafe blocks let you perform operations the compiler cannot verify:

Dereference raw pointers
Call unsafe functions
Access mutable statics
Implement unsafe traits
Access union fields

Use sparingly and document invariants. std::fmt::Display enables user-facing string formatting with {}:

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

Unlike Debug, it cannot be derived automatically. Common derivable traits include:

Debug — enables {:?} formatting
Clone / Copy — value duplication
PartialEq / Eq — equality comparison
PartialOrd / Ord — ordering
Hash — hashing support

Use #[derive(Debug, Clone)].

Question 23 Rust Programming

What is the Box smart pointer?

The ? operator placed after a Result or Option expression will:

Return the inner value if Ok/Some
Early-return the error/None to the caller if Err/None

It simplifies error propagation and reduces boilerplate. Iterators implement the Iterator trait, which requires a next() method returning Option<Item>. They are lazy — they do nothing until consumed by methods like collect(), sum(), or for loops. Box<T> allocates data on the heap and holds an owned pointer to it. Use cases:

Types with unknown size at compile time (e.g., recursive types)
Transferring ownership without copying large data
Trait objects: Box<dyn Trait>

A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move).

Question 24 Rust Programming

How does Rust's module file system work?

A module mod foo; tells the compiler to look for foo.rs or foo/mod.rs. Since Rust 2018, foo.rs with a sibling directory foo/ is preferred over foo/mod.rs. Generics allow writing code that works with multiple types:
fn largest<T: PartialOrd>(list: &[T]) -> &T
The compiler performs monomorphization — generating specialized code for each concrete type used, so there is zero runtime cost. Pattern matching uses match to destructure and branch on values:

match shape {
  Shape::Circle(r) => ...,
  Shape::Rectangle(w, h) => ...,
}

The compiler ensures all variants are handled (exhaustiveness). std::fmt::Display enables user-facing string formatting with {}:

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

Unlike Debug, it cannot be derived automatically.

Question 25 Rust Programming

What is the Display trait?

move forces the closure to take ownership of all captured variables:

let name = String::from("Rust");
let greet = move || println!("{}", name);

After this, name is no longer usable in the outer scope. Essential when sending closures to other threads. std::fmt::Display enables user-facing string formatting with {}:

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

Unlike Debug, it cannot be derived automatically. &T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it. Borrowing lets you reference a value without taking ownership. You create a reference with &. The original owner retains ownership while the borrower can read (or write, if mutable) the data.

Question 26 Rust Programming

How do you safely extract a value from an Option?

Common methods include:

unwrap() — panics if None
unwrap_or(default) — returns default if None
if let Some(v) = opt { ... } — pattern match
match — exhaustive handling
? operator — propagates None

Each value in Rust has a single owner
There can only be one owner at a time
When the owner goes out of scope, the value is dropped

Modules organize code into namespaces using mod:

mod network {
  pub fn connect() { }
}

Items are private by default; use pub to make them public. Modules can be in separate files. Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test.

Question 27 Rust Programming

What is a lifetime in Rust?

if let is a concise way to match a single pattern:

if let Some(val) = my_option {
  println!("{}", val);
}

It's syntactic sugar for a match with one arm and a wildcard. Use when you only care about one variant. A lifetime is a compile-time annotation (e.g., 'a) that tells the compiler how long a reference is valid. Lifetimes prevent dangling references by ensuring borrowed data outlives the borrower. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move). &T is an immutable reference (shared borrow) — multiple allowed simultaneously.
&mut T is a mutable reference (exclusive borrow) — only one allowed at a time, and no immutable references may coexist with it.

Question 28 Rust Programming

What is Send and Sync in Rust?

Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test. Send means a type can be transferred to another thread.
Sync means a type can be referenced from multiple threads (i.e., &T is Send).
Most types implement both automatically. Rc<T> is neither, while Arc<T> is both. dyn Trait enables dynamic dispatch via a vtable (virtual method table):
fn draw(shape: &dyn Drawable)
Unlike generics (static dispatch), the concrete type is resolved at runtime. Trade-off: slight runtime cost, but allows heterogeneous collections. unsafe blocks let you perform operations the compiler cannot verify:

Dereference raw pointers
Call unsafe functions
Access mutable statics
Implement unsafe traits
Access union fields

Use sparingly and document invariants.

Question 29 Rust Programming

What are the Fn, FnMut, and FnOnce traits?

Raw pointers *const T and *mut T are like C pointers — they can be null, dangling, or aliased. Creating them is safe, but dereferencing requires an unsafe block:

let p: *const i32 = &x;
unsafe { println!("{}", *p); }

These traits describe how closures capture variables:

Fn — captures by immutable reference
FnMut — captures by mutable reference
FnOnce — captures by value (can only be called once)

Every closure implements FnOnce; some also implement FnMut or Fn. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming. Copy allows implicit bitwise copies on assignment (stack-only types like i32, bool).
Clone requires an explicit .clone() call and can perform deep copies. All Copy types must also implement Clone.

Question 30 Rust Programming

What is Arc and Mutex for concurrency?

Channels provide message passing between threads via std::sync::mpsc (multiple producer, single consumer):

let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
let val = rx.recv().unwrap();

Cargo is Rust's build system and package manager. Key commands:

cargo new — create a project
cargo build — compile
cargo run — compile and run
cargo test — run tests

Dependencies are declared in Cargo.toml. Option<T> represents a value that may or may not exist:
enum Option<T> { Some(T), None }
It replaces null from other languages and forces you to explicitly handle the absence of a value. Arc<T> (Atomic Reference Counting) enables shared ownership across threads.
Mutex<T> provides interior mutability with locking.
Combined: Arc<Mutex<T>> allows multiple threads to safely read and write shared data.

Question 31 Rust Programming

What is Cargo?

HashMap<K, V> stores key-value pairs with O(1) average lookup:

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", 42);
let val = map.get("key");

Keys must implement Eq and Hash. Cargo is Rust's build system and package manager. Key commands:

cargo new — create a project
cargo build — compile
cargo run — compile and run
cargo test — run tests

Dependencies are declared in Cargo.toml. 'static means the reference is valid for the entire duration of the program. String literals have type &'static str because they are embedded in the binary. A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming.

Question 32 Rust Programming

What is the String vs &str distinction?

A struct is a custom data type that groups related fields. Example:
struct User { name: String, age: u32 }
Rust has three kinds: named-field structs, tuple structs, and unit structs. Pattern matching uses match to destructure and branch on values:

match shape {
  Shape::Circle(r) => ...,
  Shape::Rectangle(w, h) => ...,
}

The compiler ensures all variants are handled (exhaustiveness). Adapters transform iterators lazily (e.g., map(), filter(), take()).
Consumers drive iteration and produce a result (e.g., collect(), sum(), count(), for_each()). String is an owned, heap-allocated, growable UTF-8 string.
&str is a borrowed string slice — a reference to UTF-8 data. String literals are &'static str. Use &str for function parameters when you only need to read.

Question 33 Rust Programming

What is the Copy trait vs the Clone trait?

Copy allows implicit bitwise copies on assignment (stack-only types like i32, bool).
Clone requires an explicit .clone() call and can perform deep copies. All Copy types must also implement Clone. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move). Vec<T> is a growable, heap-allocated array. Create with:
let v = vec![1, 2, 3];
Key methods: push(), pop(), len(), iter(). It owns its elements and drops them when it goes out of scope. Raw pointers *const T and *mut T are like C pointers — they can be null, dangling, or aliased. Creating them is safe, but dereferencing requires an unsafe block:

let p: *const i32 = &x;
unsafe { println!("{}", *p); }

Question 34 Rust Programming

What is the Result type in Rust?

Result<T, E> represents success or failure:
enum Result<T, E> { Ok(T), Err(E) }
It is the standard way to handle recoverable errors in Rust, used extensively in I/O and parsing. Use lifetime parameters in angle brackets: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. This tells the compiler the returned reference lives at least as long as the shorter of x and y. HashMap<K, V> stores key-value pairs with O(1) average lookup:

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", 42);
let val = map.get("key");

Keys must implement Eq and Hash. A lifetime is a compile-time annotation (e.g., 'a) that tells the compiler how long a reference is valid. Lifetimes prevent dangling references by ensuring borrowed data outlives the borrower.

Question 35 Rust Programming

What are iterators in Rust?

Common methods include:

unwrap() — panics if None
unwrap_or(default) — returns default if None
if let Some(v) = opt { ... } — pattern match
match — exhaustive handling
? operator — propagates None

A trait defines a set of methods that a type must implement, similar to interfaces in other languages:

trait Summary {
  fn summarize(&self) -> String;
}

Traits enable polymorphism and generic programming. Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test. Iterators implement the Iterator trait, which requires a next() method returning Option<Item>. They are lazy — they do nothing until consumed by methods like collect(), sum(), or for loops.

Question 36 Rust Programming

What are iterator adapters vs consumers?

A lifetime is a compile-time annotation (e.g., 'a) that tells the compiler how long a reference is valid. Lifetimes prevent dangling references by ensuring borrowed data outlives the borrower. Use lifetime parameters in angle brackets: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. This tells the compiler the returned reference lives at least as long as the shorter of x and y. Adapters transform iterators lazily (e.g., map(), filter(), take()).
Consumers drive iteration and produce a result (e.g., collect(), sum(), count(), for_each()). Use std::thread::spawn:

let handle = thread::spawn(|| {
  println!("Hello from thread!");
});
handle.join().unwrap();

Closures sent to threads typically need move to own their data.

Question 37 Rust Programming

What is borrowing in Rust?

Common methods include:

unwrap() — panics if None
unwrap_or(default) — returns default if None
if let Some(v) = opt { ... } — pattern match
match — exhaustive handling
? operator — propagates None

panic! is for unrecoverable errors — it unwinds the stack and crashes the thread.
Result is for recoverable errors — the caller decides how to handle the failure. Prefer Result in library code. From<T> defines how to create a type from another:
impl From<&str> for String
Into<T> is the reciprocal — implementing From automatically provides Into. Widely used for ergonomic type conversions and error handling. Borrowing lets you reference a value without taking ownership. You create a reference with &. The original owner retains ownership while the borrower can read (or write, if mutable) the data.

Question 38 Rust Programming

What is dynamic dispatch with dyn Trait?

while let loops as long as a pattern matches:

while let Some(val) = stack.pop() {
  println!("{}", val);
}

Useful for iterating until an Option returns None. Rust is a systems programming language focused on safety, speed, and concurrency. It achieves memory safety without a garbage collector through its ownership system. A crate is the smallest compilation unit. It can be a binary crate (with a main function) or a library crate. External crates are published on crates.io and added via Cargo.toml. dyn Trait enables dynamic dispatch via a vtable (virtual method table):
fn draw(shape: &dyn Drawable)
Unlike generics (static dispatch), the concrete type is resolved at runtime. Trade-off: slight runtime cost, but allows heterogeneous collections.

Question 39 Rust Programming

What are the three ownership rules in Rust?

std::fmt::Display enables user-facing string formatting with {}:

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

Unlike Debug, it cannot be derived automatically. Trait bounds constrain generic types to those implementing specific traits:
fn print_summary<T: Summary>(item: &T)
Or using where syntax:
fn print_summary<T>(item: &T) where T: Summary

Each value in Rust has a single owner
There can only be one owner at a time
When the owner goes out of scope, the value is dropped

String is an owned, heap-allocated, growable UTF-8 string.
&str is a borrowed string slice — a reference to UTF-8 data. String literals are &'static str. Use &str for function parameters when you only need to read.

Question 40 Rust Programming

How do you create a new thread in Rust?

Cargo is Rust's build system and package manager. Key commands:

cargo new — create a project
cargo build — compile
cargo run — compile and run
cargo test — run tests

Dependencies are declared in Cargo.toml. Channels provide message passing between threads via std::sync::mpsc (multiple producer, single consumer):

let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
let val = rx.recv().unwrap();

Modules organize code into namespaces using mod:

mod network {
  pub fn connect() { }
}

Items are private by default; use pub to make them public. Modules can be in separate files. Use std::thread::spawn:

let handle = thread::spawn(|| {
  println!("Hello from thread!");
});
handle.join().unwrap();

Closures sent to threads typically need move to own their data.

Question 41 Rust Programming

What is the Option type in Rust?

An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. Common derivable traits include:

Debug — enables {:?} formatting
Clone / Copy — value duplication
PartialEq / Eq — equality comparison
PartialOrd / Ord — ordering
Hash — hashing support

Use #[derive(Debug, Clone)]. Option<T> represents a value that may or may not exist:
enum Option<T> { Some(T), None }
It replaces null from other languages and forces you to explicitly handle the absence of a value. Use an impl block:

impl User {
  fn greet(&self) -> String {
    format!("Hi, {}", self.name)
  }
}

The first parameter is typically &self, &mut self, or self.

Question 42 Rust Programming

What is the HashMap type in Rust?

HashMap<K, V> stores key-value pairs with O(1) average lookup:

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", 42);
let val = map.get("key");

Keys must implement Eq and Hash. Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test. Use lifetime parameters in angle brackets: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. This tells the compiler the returned reference lives at least as long as the shorter of x and y. Cargo is Rust's build system and package manager. Key commands:

cargo new — create a project
cargo build — compile
cargo run — compile and run
cargo test — run tests

Dependencies are declared in Cargo.toml.

Question 43 Rust Programming

How do you implement a trait for a type?

Modules organize code into namespaces using mod:

mod network {
  pub fn connect() { }
}

Items are private by default; use pub to make them public. Modules can be in separate files. Use std::thread::spawn:

let handle = thread::spawn(|| {
  println!("Hello from thread!");
});
handle.join().unwrap();

Closures sent to threads typically need move to own their data. Use impl Trait for Type:

impl Summary for Article {
  fn summarize(&self) -> String {
    format!("{}", self.title)
  }
}

while let loops as long as a pattern matches:

while let Some(val) = stack.pop() {
  println!("{}", val);
}

Useful for iterating until an Option returns None.

Question 44 Rust Programming

What does the move keyword do with closures?

Pattern matching uses match to destructure and branch on values:

match shape {
  Shape::Circle(r) => ...,
  Shape::Rectangle(w, h) => ...,
}

The compiler ensures all variants are handled (exhaustiveness). move forces the closure to take ownership of all captured variables:

let name = String::from("Rust");
let greet = move || println!("{}", name);

After this, name is no longer usable in the outer scope. Essential when sending closures to other threads. These traits describe how closures capture variables:

Fn — captures by immutable reference
FnMut — captures by mutable reference
FnOnce — captures by value (can only be called once)

Every closure implements FnOnce; some also implement FnMut or Fn. A closure is an anonymous function that can capture variables from its enclosing scope:
let add = |a, b| a + b;
Closures can capture by reference, mutable reference, or value (move).

Question 45 Rust Programming

What is a crate in Rust?

panic! is for unrecoverable errors — it unwinds the stack and crashes the thread.
Result is for recoverable errors — the caller decides how to handle the failure. Prefer Result in library code. Box<T> allocates data on the heap and holds an owned pointer to it. Use cases:

Types with unknown size at compile time (e.g., recursive types)
Transferring ownership without copying large data
Trait objects: Box<dyn Trait>

Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test. A crate is the smallest compilation unit. It can be a binary crate (with a main function) or a library crate. External crates are published on crates.io and added via Cargo.toml.

Question 46 Rust Programming

What are trait bounds in generics?

These traits describe how closures capture variables:

Fn — captures by immutable reference
FnMut — captures by mutable reference
FnOnce — captures by value (can only be called once)

Every closure implements FnOnce; some also implement FnMut or Fn. dyn Trait enables dynamic dispatch via a vtable (virtual method table):
fn draw(shape: &dyn Drawable)
Unlike generics (static dispatch), the concrete type is resolved at runtime. Trade-off: slight runtime cost, but allows heterogeneous collections. Trait bounds constrain generic types to those implementing specific traits:
fn print_summary<T: Summary>(item: &T)
Or using where syntax:
fn print_summary<T>(item: &T) where T: Summary A module mod foo; tells the compiler to look for foo.rs or foo/mod.rs. Since Rust 2018, foo.rs with a sibling directory foo/ is preferred over foo/mod.rs.

Question 47 Rust Programming

How do you write unit tests in Rust?

if let is a concise way to match a single pattern:

if let Some(val) = my_option {
  println!("{}", val);
}

It's syntactic sugar for a match with one arm and a wildcard. Use when you only care about one variant. Place tests in the same file with a #[cfg(test)] module:

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn it_works() {
    assert_eq!(2 + 2, 4);
  }
}

Run with cargo test. Generics allow writing code that works with multiple types:
fn largest<T: PartialOrd>(list: &[T]) -> &T
The compiler performs monomorphization — generating specialized code for each concrete type used, so there is zero runtime cost. move forces the closure to take ownership of all captured variables:

let name = String::from("Rust");
let greet = move || println!("{}", name);

After this, name is no longer usable in the outer scope. Essential when sending closures to other threads.

Question 48 Rust Programming

What is an enum in Rust?

Cargo is Rust's build system and package manager. Key commands:

cargo new — create a project
cargo build — compile
cargo run — compile and run
cargo test — run tests

Dependencies are declared in Cargo.toml. A module mod foo; tells the compiler to look for foo.rs or foo/mod.rs. Since Rust 2018, foo.rs with a sibling directory foo/ is preferred over foo/mod.rs. An enum defines a type that can be one of several variants. Variants can hold data:

enum Shape {
  Circle(f64),
  Rectangle(f64, f64),
}

Enums are central to Rust's type system and pattern matching. Option<T> represents a value that may or may not exist:
enum Option<T> { Some(T), None }
It replaces null from other languages and forces you to explicitly handle the absence of a value.

Question 49 Rust Programming

What is Rust?

String is an owned, heap-allocated, growable UTF-8 string.
&str is a borrowed string slice — a reference to UTF-8 data. String literals are &'static str. Use &str for function parameters when you only need to read. Copy allows implicit bitwise copies on assignment (stack-only types like i32, bool).
Clone requires an explicit .clone() call and can perform deep copies. All Copy types must also implement Clone. A lifetime is a compile-time annotation (e.g., 'a) that tells the compiler how long a reference is valid. Lifetimes prevent dangling references by ensuring borrowed data outlives the borrower. Rust is a systems programming language focused on safety, speed, and concurrency. It achieves memory safety without a garbage collector through its ownership system.

Question 50 Rust Programming

How does the ? operator work for error handling?

The ? operator placed after a Result or Option expression will:

Return the inner value if Ok/Some
Early-return the error/None to the caller if Err/None

It simplifies error propagation and reduces boilerplate. Common derivable traits include:

Debug — enables {:?} formatting
Clone / Copy — value duplication
PartialEq / Eq — equality comparison
PartialOrd / Ord — ordering
Hash — hashing support

Use #[derive(Debug, Clone)]. Use lifetime parameters in angle brackets: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. This tells the compiler the returned reference lives at least as long as the shorter of x and y. Rust is a systems programming language focused on safety, speed, and concurrency. It achieves memory safety without a garbage collector through its ownership system.