Rust Interview Questions

1. What is Rust and what problems does it solve compared to C++?

2. What is ownership in Rust and what are its three rules?

3. What is borrowing in Rust and how do references work?

4. What is the difference between a mutable and an immutable reference in Rust?

5. What are lifetimes in Rust and why does the borrow checker need them?

6. What is the difference between move, copy, and clone semantics in Rust?

7. What is the difference between String and &str in Rust?

8. What is the difference between a Vec and an array in Rust?

9. What are traits in Rust and how do they compare to interfaces?

10. What is the difference between a struct and an enum in Rust?

11. How does Rust handle null with the Option type?

12. How does Rust handle errors with the Result type and the ? operator?

13. What is pattern matching in Rust and how does the match expression work?

14. What is the difference between Box, Rc, and Arc in Rust?

15. What is interior mutability in Rust and how do Cell and RefCell provide it?

16. What are closures in Rust and how do Fn, FnMut, and FnOnce differ?

17. What are iterators in Rust and how does lazy evaluation work?

18. What is the difference between fearless concurrency and data races in Rust?

19. What are the Send and Sync traits in Rust and what do they guarantee?

20. What is the difference between static and dynamic dispatch in Rust?

21. What are generics in Rust and how do trait bounds constrain them?

22. What is a macro in Rust and how do declarative and procedural macros differ?

23. What is the difference between panic! and returning a Result in Rust?

24. What is the newtype pattern in Rust and when do you use it?

25. What is zero-cost abstraction in Rust and why does it matter?

26. How does Rust manage memory without a garbage collector?

27. What is the difference between Copy and Clone traits in Rust?

28. What is a slice in Rust and how does it borrow from a collection?

29. What is async/await in Rust and how do futures work?

30. What are modules and crates in Rust and how does the module system work?

31. Why does Rust async need Pin and Unpin, and when do you have to care?

32. What does unsafe Rust actually allow, and what invariants must you uphold?

33. How does Drop work in Rust, what order do values drop in, and where does it bite you?

34. What makes a trait object-safe in Rust, and how do you work around the rules?

35. How does Cargo feature unification work, and how do you debug a feature that mysteriously turns on?

36. How do you debug a deadlock or a poisoned Mutex in a Rust service?

37. What happens if you block inside an async task, and how do you detect and fix it?

38. How do you expose a Rust library over a C FFI boundary safely?

39. How do you design error types for a Rust library versus an application?

40. How do you profile and optimise a slow Rust program without guessing?

41. What does a serious Rust testing strategy include beyond #[test] unit tests?

42. What are higher-ranked trait bounds and variance in Rust, and when do they show up in errors?

43. What are Rust's lifetime elision rules, and when must you write lifetimes explicitly?

44. Why does RefCell panic with "already borrowed", and how do you design around it?

45. When should you use Cow in Rust, and what does it actually save?

46. How do you choose between Arc<Mutex<T>>, RwLock and channels for shared state in Rust?

47. What is the orphan rule in Rust, and how do you implement a foreign trait for a foreign type?

48. How does monomorphisation affect Rust compile times and binary size, and when do you use dyn instead?

49. When do you use thiserror versus anyhow in Rust, and how do you add context to errors?

50. What is cancellation safety in Rust async, and how does select! lose data?

51. Why does tokio::spawn require Send + 'static, and how do you satisfy it without cloning everything?

52. How do you return a future from a trait method in Rust, and what are the trade-offs?

53. What counts as undefined behaviour in Rust, and how do you detect it in unsafe code?

54. Are Rust iterator chains as fast as hand-written loops, and when are they not?

55. How do Deref coercion, AsRef and Borrow differ, and which should an API accept?

56. Why are Rust build times slow, and what actually improves them?

57. What are const generics and const fn in Rust, and where do they genuinely help?

58. How do atomics and memory ordering work in Rust, and when is Relaxed enough?

59. Why do you need mem::swap, mem::take and mem::replace in Rust?

60. What is PhantomData used for in Rust, and what does it change about a type?

61. When should a Rust trait use an associated type instead of a generic parameter?