What happens when you assign one String to another variable in Rust, like let b = a;?

Ownership moves to the new variable and the original becomes invalid.

Both variables become valid references to the same heap data.

The String is deep-cloned into the new variable automatically.

The compiler refuses to compile without an explicit lifetime annotation.

What does the Drop trait do?

Runs custom cleanup code automatically when a value goes out of scope.

Marks a value as garbage for a runtime collector to clean up later.

Forces the borrow checker to ignore the value.

Returns ownership back to the caller.

How many mutable references to the same value can exist at the same time?

Unlimited, as long as they have different lifetimes.

As many as there are matching immutable references.

Can a mutable reference exist at the same time as immutable references to the same value?

No, mutable and immutable references are mutually exclusive in the same scope.

Yes, mutable references override immutable ones.

Yes, but only inside an unsafe block.

Yes, as long as the mutable reference is created first.

What is the borrow checker?

A compile-time analysis that enforces ownership and borrowing rules.

A runtime check that detects null pointers.

A linter that scans crates for unsafe code.

What does &mut T mean?

A mutable, exclusive reference to a value of type T.

A raw pointer to a mutable variable.

A shared reference that can mutate the value.

What is the purpose of a lifetime annotation like 'a?

It tells the borrow checker how long a reference must remain valid.

It forces the compiler to extend a value's lifetime.

It marks a function as a constant expression.

It enables garbage collection for the value.

What does the 'static lifetime mean?

The reference is valid for the entire program.

The value is allocated on the stack.

The compiler ignores its lifetime.

When can you omit lifetime annotations on function references?

Whenever the compiler can infer them from the standard elision rules.

Always. Lifetimes are entirely optional.

Only when the function has no parameters.

What is a trait in Rust?

A shared interface that types can implement, similar to an interface or type class in other languages.

A way to allocate memory on the heap.

What does impl Trait mean when used as a return type?

The function returns some concrete type that implements the trait, without naming it.

The function returns a heap-allocated trait object.

The function returns the trait itself.

The function panics if the trait is not implemented.

What is the key difference between dyn Trait and impl Trait?

dyn Trait is dynamic dispatch through a vtable; impl Trait is static dispatch resolved at compile time.

They are identical aliases for the same thing.

What does #[derive(Debug)] do?

Auto-generates an implementation of the Debug trait so you can format with {:?}.

Marks the type for the borrow checker.

What does "exhaustiveness" mean in a match expression?

The match must cover every possible value of the scrutinee, often by using _ for the rest.

Every arm must include a guard clause.

Every arm must return the same value.

The match cannot also use if let.

When would you reach for if let instead of match?

When you need to handle only one specific pattern and ignore everything else.

When you want exhaustive case coverage.

It is deprecated; you should always use match.

What does the _ pattern do inside match?

It matches any value without binding it, acting as a catch-all.

It matches anything and binds it to a variable named _.

It skips the current loop iteration.

What is the Result type?

An enum with Ok(T) for success and Err(E) for failure.

A type that always panics on error.

A trait for fallible operations.

What does the ? operator do?

It returns early from the function on an Err (or None), propagating the value to the caller.

It marks the expression as unsafe.

It coerces a value into Option::Some.

When should you panic! instead of returning a Result?

For programmer bugs and unrecoverable states. Result is preferred for expected failures.

Always. panic! is faster than handling errors.

Whenever the function returns an Option.

Allocates a value on the heap with a single owner.

Allocates a value on the stack.

Provides shared, mutable access across threads.

What is the difference between Rc and Arc ?

Rc is single-threaded reference counting; Arc uses atomic counters and is safe across threads.

Arc is for arrays, Rc is for single values.

They are aliases for the same type.

Rc is heap-allocated, Arc is stack-allocated.

What does RefCell enable?

Interior mutability with runtime borrow checking that can panic on violation.

Compile-time mutability checks.

What do the Send and Sync marker traits mean?

Send types can be transferred across thread boundaries; Sync types can be safely shared between threads via references.

They are deprecated traits from early Rust.

They enable network sending and synchronization protocols.

They are macros that generate threading code.

What's the recommended primitive in std for passing messages between threads?

A channel from std::sync::mpsc.

Why is Rust's concurrency model called "fearless concurrency"?

The ownership system and Send/Sync traits catch data races and many concurrency bugs at compile time.

The compiler eliminates all locking automatically.

Rust does not actually support concurrency.

Threads cannot crash a Rust program.

Rust's package manager and build tool. It also runs tests, builds docs, and publishes crates.

A virtual machine for Rust programs.

A configuration file declaring a package's metadata, dependencies, and build settings.

A binary artifact produced by the compiler.

A lockfile that pins exact dependency versions.

Quizzes

Rust: Ownership, Borrowing & Memory Safety

Rust Systems Programming Programming

Rust: Ownership, Borrowing & Memory Safety

Mohammad Abu Mattar20 QuestionsIntermediatePublished: 28 May, 2026

This quiz tests your grip on the parts of Rust that trip up newcomers and pay off later: ownership and moves, borrowing and lifetimes, traits and generics, pattern matching, error handling with Result, smart pointers, fearless concurrency, and the cargo workflow. Take your time, read each option carefully, and use the hint if you get stuck.