Advanced Rust Interview Questions: Master Coding Patterns

Rust has rapidly become one of the most loved languages, especially for systems programming, due to its memory safety guarantees without a garbage collector. In advanced interviews, you'll be tested on more than just syntax—you need to demonstrate a deep understanding of ownership, lifetimes, concurrency, and zero-cost abstractions. This guide covers real interview questions, from implementing a thread-safe counter to designing a custom iterator. Each question includes a solution with time and space complexity, and tips on how to present your answer. Whether you're targeting a role at a startup or a FAANG company, mastering these patterns will set you apart. Let's dive into the questions that separate Rust novices from experts.

1. Ownership and Borrowing: The Foundation

Ownership is Rust's most unique feature. Every value has a single owner, and ownership can be transferred (moved) or borrowed. In interviews, you'll be asked to explain ownership rules and predict compiler errors. For example, consider a function that takes ownership of a String and then tries to use it again. The compiler will reject it. To avoid this, you can pass a reference. Understanding when to use &T vs &mut T is crucial. A common question: 'What is the difference between a move and a copy?' Types that implement Copy (like integers) are copied implicitly; others are moved. You can also implement Clone for explicit duplication. In an interview, demonstrate by writing a small code snippet that shows ownership transfer and borrowing.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 moved to s2
    // println!("{}", s1); // error: use after move
    let s3 = &s2; // borrow s2
    println!("{}", s3); // ok
}

2. Lifetimes: Ensuring References are Valid

Lifetimes are Rust's way of ensuring that references are always valid. They are often elided (inferred) but must be explicit in function signatures when multiple references are involved. A classic interview question: 'Write a function that returns the longest of two string slices.' You need to annotate that the returned reference lives as long as both inputs. The solution uses a generic lifetime 'a. In an interview, explain that lifetimes are not about runtime but compile-time checks. Practice by writing functions with multiple references and understanding lifetime elision rules.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
fn main() {
    let s1 = String::from("short");
    let result;
    {
        let s2 = String::from("longer");
        result = longest(&s1, &s2);
        println!("{}", result);
    }
    // println!("{}", result); // error: s2 does not live long enough
}

3. Enums and Pattern Matching: Expressive Data Modeling

Rust's enums are powerful, especially with pattern matching. They can hold data (like Option<T> and Result<T, E>). An interview question might ask: 'Implement a binary tree using enums.' The solution uses an enum with variants for Empty and Node containing a value and two child boxes. Pattern matching allows elegant traversal. Another common question: 'How do you handle errors without exceptions?' Use Result and match or combinators like map, and_then, and unwrap_or. In an interview, show how to use if let for concise matching.

enum Tree<T> {
    Empty,
    Node(T, Box<Tree<T>>, Box<Tree<T>>),
}

fn depth<T>(tree: &Tree<T>) -> u32 {
    match tree {
        Tree::Empty => 0,
        Tree::Node(_, left, right) => 1 + std::cmp::max(depth(left), depth(right)),
    }
}

fn main() {
    let tree = Tree::Node(1,
        Box::new(Tree::Node(2, Box::new(Tree::Empty), Box::new(Tree::Empty))),
        Box::new(Tree::Empty));
    println!("Depth: {}", depth(&tree));
}

4. Traits and Generics: Polymorphism without Inheritance

Traits define shared behavior. Generics allow code to work with multiple types. An interview question: 'Implement a generic function that returns the largest element in a slice.' You need to bound the type with PartialOrd. Another question: 'What is trait object dispatch?' Explain dyn Trait for dynamic dispatch vs generics for static dispatch. In an interview, demonstrate by writing a trait Area for shapes and implementing it for Circle and Rectangle. Show how to use trait bounds in functions.

trait Area {
    fn area(&self) -> f64;
}

struct Circle { radius: f64 }
struct Rectangle { width: f64, height: f64 }

impl Area for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
}
impl Area for Rectangle {
    fn area(&self) -> f64 { self.width * self.height }
}

fn print_area<T: Area>(shape: &T) {
    println!("Area: {}", shape.area());
}

fn main() {
    let c = Circle { radius: 2.0 };
    let r = Rectangle { width: 3.0, height: 4.0 };
    print_area(&c);
    print_area(&r);
}

5. Concurrency: Fearless Concurrency with Threads and Async

Rust's type system prevents data races at compile time. Interview questions often involve Mutex, Arc, and channels. A classic: 'Implement a thread-safe counter using Arc<Mutex<u32>>.' Another: 'Explain the difference between threads and async tasks.' Async in Rust uses async/await and an executor like tokio. In an interview, show how to spawn threads and share data safely. Also, demonstrate a simple async function that reads from a file. Emphasize that Rust guarantees no data races.

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

6. Smart Pointers: Box, Rc, RefCell, and More

Smart pointers manage heap-allocated data and provide additional guarantees. Box<T> is for single ownership on the heap. Rc<T> enables multiple ownership (reference counting) in single-threaded contexts. RefCell<T> provides interior mutability with runtime borrow checking. An interview question: 'Implement a simple linked list using Box.' Another: 'When would you use Rc<RefCell<T>>?' This combination is common for graph structures. In an interview, explain the trade-offs: Box is simple, Rc has runtime overhead, RefCell can panic at runtime. Demonstrate a use case for each.

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    children: Vec<Rc<RefCell<Node>>>,
}

fn main() {
    let leaf = Rc::new(RefCell::new(Node { value: 3, children: vec![] }));
    let branch = Rc::new(RefCell::new(Node { value: 5, children: vec![Rc::clone(&leaf)] }));
    println!("leaf: {:?}", leaf);
    println!("branch: {:?}", branch);
}

7. Error Handling: Result, Option, and Custom Errors

Rust handles errors without exceptions using Result<T, E> and Option<T>. An interview question: 'Write a function that reads a file and returns its contents as a String, handling errors gracefully.' Use std::fs::read_to_string which returns Result. Another question: 'How do you define custom error types?' Implement the Error trait and use thiserror or anyhow crates. In an interview, show how to use ? operator to propagate errors and match for fine-grained control. Emphasize that unwrap() should be avoided in production.

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file("hello.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

8. Iterators and Closures: Functional Programming in Rust

Rust's iterators are lazy and composable. An interview question: 'Given a vector of integers, return the sum of squares of even numbers.' Use filter, map, and sum. Another question: 'Implement a custom iterator.' You need to implement the Iterator trait. Closures are anonymous functions that can capture their environment. In an interview, explain how closures can borrow or move variables. Demonstrate using into_iter, iter, and iter_mut. Show how to create a closure that modifies captured variables.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum_squares_even: i32 = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .sum();
    println!("Sum of squares of even numbers: {}", sum_squares_even);
}